require 'parslet'

module Junoser
  class Parser < Parslet::Parser
    def parse_lines(config)
      lines = config.split("\n").map(&:strip)
      lines_without_deactivate = lines.reject {|l| l =~ /^deactivate/ }

      lines.inject(true) do |passed, line|
        passed & parse_line(line, lines_without_deactivate)
      end
    end

    def parse_line(line, lines_without_deactivate)
      if line =~ /^deactivate/
        if lines_without_deactivate.grep(/^#{line.sub(/^deactivate/, 'set')}/).empty?
          $stderr.puts %(Corresponding "set" statement is not found:  #{line})
          return false
        else
          return true
        end
      end

      begin
        # .xsd doesn't include "apply-groups"
        if line =~ /(.*)\s+apply-groups(-except)?\s+(\S+|\[.*\])$/
          return $1 == 'set' ? true : parse($1)
        end

        parse line
        true
      rescue Parslet::ParseFailed
        $stderr.puts "Invalid syntax:  #{line}"
        false
      end
    end

    # block with children maybe
    def b(object, *children)
      children.inject(object) {|rule, child| rule.as(:label) >> (space >> child.as(:child) | eos) }
    end

    # with an argument, and children maybe
    def a(object, arg, *children)
      b(object.as(:statement) >> space >> arg.as(:argument), *children)
    end

    # choice
    def c(*objects)
      objects.inject {|rule, object| rule | object }
    end

    def ca(*objects)
      objects.inject {|rule, object| rule | object } | arg
    end

    # sequence
    def s(*objects)
      # TODO:  eval "minOccurs" attribute of choice element
      objects.inject {|rule, object| rule >> (space >> object).maybe }
    end

    # sequential choice
    def sc(*objects)
      (c(*objects) >> space.maybe).repeat(0)
    end

    def sca(*objects)
      (c(*objects, arg) >> space.maybe).repeat(0)
    end

    def enum(object)
      (object.as(:enum))
    end

    rule(:arg)     { match('\S').repeat(1) }
    rule(:space)   { match('\s').repeat(1) }
    rule(:any)     { match('.').repeat(1) }
    rule(:eos)     { match('$') }
    rule(:dotted)  { match('[^. \t\n\r\f]').repeat(1) >> str('.') >> match('[^. \t\n\r\f]').repeat(1) }
    rule(:quote)   { str('"') >> match('[^"]').repeat(1) >> str('"') }
    rule(:address) { match('[0-9a-fA-F:.]').repeat(1) }
    rule(:prefix ) { address >> (str('/') >> match('[0-9]').repeat(1)).maybe }

    root(:set)
    rule(:set) { str('set') >> space >> configuration.as(:config) >> comment.maybe }

    rule(:comment) { space.maybe >> (hash_comment | slash_asterisk) }
    rule(:hash_comment) { str('#') >> any.maybe }
    rule(:slash_asterisk) { str('/*') >> match('(?!\*\/).').repeat(0) >> str('*/') }

    rule(:undocumented) do
          s(
            any
          )
    end

    rule(:key_attribute_long_type) do
          arg.as(:arg)
    end

    rule(:key_attribute_string_type) do
          arg.as(:arg)
    end

    rule(:key_attribute_ulong_type) do
          arg.as(:arg)
    end

    rule(:filename) do
          arg.as(:arg)
    end

    rule(:client_filename) do
          arg.as(:arg)
    end

    rule(:hostname) do
          arg.as(:arg)
    end

    rule(:ipaddr) do
          arg.as(:arg)
    end

    rule(:sysid) do
          arg.as(:arg)
    end

    rule(:interface_device) do
          arg.as(:arg)
    end

    rule(:bits) do
          arg.as(:arg)
    end

    rule(:isoaddr) do
          arg.as(:arg)
    end

    rule(:ipprefix) do
          arg.as(:arg)
    end

    rule(:ipprefix_mandatory) do
          arg.as(:arg)
    end

    rule(:interface_unit) do
          arg.as(:arg)
    end

    rule(:ipaddr_or_interface) do
          arg.as(:arg)
    end

    rule(:areaid) do
          arg.as(:arg)
    end

    rule(:interface_name) do
          arg.as(:arg)
    end

    rule(:community) do
          arg.as(:arg)
    end

    rule(:interface_wildcard) do
          arg.as(:arg)
    end

    rule(:unreadable) do
          arg.as(:arg)
    end

    rule(:ipprefix_optional) do
          arg.as(:arg)
    end

    rule(:policy_algebra) do
          arg.as(:arg)
    end

    rule(:regular_expression) do
      (quote | arg).as(:arg)
    end


    rule(:group_glob) do
          arg.as(:arg)
    end

    rule(:atm_vci) do
          arg.as(:arg)
    end

    rule(:ipprefix_only) do
          arg.as(:arg)
    end

    rule(:ipv4addr) do
          arg.as(:arg)
    end

    rule(:ipv4prefix) do
          arg.as(:arg)
    end

    rule(:ipv4prefix_mandatory) do
          arg.as(:arg)
    end

    rule(:ipv4addr_or_interface) do
          arg.as(:arg)
    end

    rule(:ipv4prefix_optional) do
          arg.as(:arg)
    end

    rule(:ipv4prefix_only) do
          arg.as(:arg)
    end

    rule(:ipv6addr) do
          arg.as(:arg)
    end

    rule(:ipv6prefix) do
          arg.as(:arg)
    end

    rule(:ipv6prefix_mandatory) do
          arg.as(:arg)
    end

    rule(:ipv6addr_or_interface) do
          arg.as(:arg)
    end

    rule(:ipv6prefix_optional) do
          arg.as(:arg)
    end

    rule(:ipv6prefix_only) do
          arg.as(:arg)
    end

    rule(:interface_device_wildcard) do
          arg.as(:arg)
    end

    rule(:interface_unit_wildcard) do
          arg.as(:arg)
    end

    rule(:time) do
          arg.as(:arg)
    end

    rule(:mac_addr) do
          arg.as(:arg)
    end

    rule(:mac_addr_prefix) do
          arg.as(:arg)
    end

    rule(:mac_unicast) do
          arg.as(:arg)
    end

    rule(:mac_unicast_prefix) do
          arg.as(:arg)
    end

    rule(:mac_multicast) do
          arg.as(:arg)
    end

    rule(:mac_multicast_prefix) do
          arg.as(:arg)
    end

    rule(:mpls_label) do
          arg.as(:arg)
    end

    rule(:float) do
          arg.as(:arg)
    end

    rule(:unsigned_float) do
          arg.as(:arg)
    end

    rule(:isoprefix) do
          arg.as(:arg)
    end

    rule(:isosysid) do
          arg.as(:arg)
    end

    rule(:interface_range_wild) do
          arg.as(:arg)
    end

    rule(:fc_addr) do
          arg.as(:arg)
    end

    rule(:wwn) do
          arg.as(:arg)
    end

    rule(:logfilename) do
          arg.as(:arg)
    end

    rule(:esi) do
          arg.as(:arg)
    end

    rule(:typedef) do
          arg.as(:arg)
    end

    rule(:time_of_day) do
          arg.as(:arg)
    end

    rule(:date) do
          arg.as(:arg)
    end

    rule(:configuration) do
          c(
              a(str("rcsid"), arg),
              a(str("version"), arg),
              a(str("groups"), arg, configuration),
              b(str("system"),
                juniper_system
              ),
              b(str("logical-systems"),
                juniper_logical_system
              ),
              b(str("chassis"),
                chassis_type
              ),
              b(str("services"),
                  c(
                      b(str("analytics"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("all") | str("configuration") | str("rtsock") | str("client-server") | str("interface") | str("xmlproxy")),
                                          sc(
                                              str("disable")
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(a(str("export-profiles"), arg),
                                  c(
                                      b(str("stream-format"),
                                        (str("gpb") | str("json") | str("csv") | str("tsv"))
                                      ),
                                      b(str("interface"),
                                          c(
                                              str("information"),
                                              b(str("statistics"),
                                                  c(
                                                      str("traffic"),
                                                      str("queue")
                                                  )
                                              ),
                                              b(str("status"),
                                                  c(
                                                      str("link"),
                                                      str("traffic"),
                                                      str("queue")
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("system"),
                                          c(
                                              str("information"),
                                              b(str("status"),
                                                  c(
                                                      str("traffic"),
                                                      str("queue")
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("resource-profiles"), arg),
                                  c(
                                      str("queue-monitoring"),
                                      str("no-queue-monitoring"),
                                      str("traffic-monitoring"),
                                      str("no-traffic-monitoring"),
                                      b(str("depth-threshold"),
                                          sc(
                                              a(str("high"), arg),
                                              a(str("low"), arg)
                                          )
                                      ).as(:oneline),
                                      b(str("latency-threshold"),
                                          sc(
                                              a(str("high"), arg),
                                              a(str("low"), arg)
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(str("resource"),
                                  c(
                                      b(str("system"),
                                          c(
                                              a(str("resource-profile"), arg),
                                              b(str("polling-interval"),
                                                  c(
                                                      a(str("traffic-monitoring"), arg),
                                                      a(str("queue-monitoring"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("interfaces"),
                                          c(
                                                interface_type
                                          )
                                      )
                                  )
                              ),
                              b(str("collector"),
                                  c(
                                      b(str("local"),
                                          c(
                                              b(str("file"),
                                                  sc(
                                                        filename,
                                                      a(str("size"), arg),
                                                      a(str("files"), arg)
                                                  )
                                              ).as(:oneline)
                                          )
                                      ),
                                      b(a(str("address"), arg),
                                          c(
                                              b(a(str("port"), arg),
                                                  c(
                                                      a(str("transport"), enum(str("tcp") | str("udp")),
                                                          c(
                                                              a(str("export-profile"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("traffic-statistics"),
                                  c(
                                      b(str("file"),
                                          sc(
                                                filename,
                                              a(str("size"), arg),
                                              a(str("files"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("interval"), arg)
                                  )
                              ),
                              b(str("queue-statistics"),
                                  c(
                                      b(str("file"),
                                          sc(
                                                filename,
                                              a(str("size"), arg),
                                              a(str("files"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("interval"), arg)
                                  )
                              ),
                              b(str("interfaces"),
                                  c(
                                        interface_type
                                  )
                              ),
                              b(str("streaming-servers"),
                                  c(
                                      b(a(str("address"), arg),
                                          c(
                                              b(a(str("port"), arg),
                                                  c(
                                                      b(str("stream-format"),
                                                        (str("json") | str("csv") | str("tsv"))
                                                      ),
                                                      a(str("stream-type"), enum(str("traffic-statistics") | str("queue-statistics")))
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("streaming-server"), arg),
                                  c(
                                      b(str("remote-address"),
                                        ipv4addr
                                      ),
                                      a(str("remote-port"), arg),
                                      b(str("transport"),
                                        (str("udp") | str("grpc"))
                                      )
                                  )
                              ),
                              b(a(str("export-profile"), arg),
                                  c(
                                      b(str("local-address"),
                                        ipv4addr
                                      ),
                                      a(str("local-port"), arg),
                                      a(str("dscp"), arg),
                                      a(str("forwarding-class"), arg),
                                      b(str("loss-priority"),
                                        (str("low") | str("high") | str("medium-low") | str("medium-high"))
                                      ),
                                      a(str("reporting-rate"), arg),
                                      a(str("payload-size"), arg),
                                      b(str("format"),
                                        (str("gpb") | str("gpb-sdm") | str("gpb-gnmi"))
                                      ),
                                      b(str("transport"),
                                        (str("udp"))
                                      )
                                  )
                              ),
                              b(a(str("sensor"), arg),
                                  c(
                                      a(str("server-name"), arg),
                                      a(str("export-name"), arg),
                                      a(str("polling-interval"), arg),
                                      a(str("resource"), arg),
                                      a(str("resource-filter"), arg),
                                      a(str("subscription-id"), arg),
                                      str("suppress-zeros"),
                                      a(str("reporting-rate"), arg),
                                      a(str("end-of-sync-identifiers"), arg),
                                      str("target-defined"),
                                      b(str("life-time"),
                                        (str("long-lived") | str("one-off"))
                                      )
                                  )
                              ),
                              b(str("agent"),
                                  c(
                                      b(a(str("service-agents"), arg),
                                          c(
                                              b(str("inputs"),
                                                  c(
                                                      b(str("input-jti-ipfix"),
                                                          c(
                                                              b(str("parameters"),
                                                                  c(
                                                                      b(a(str("record-group"), arg),
                                                                          c(
                                                                              a(str("reporting-interval"), arg),
                                                                              b(str("record"),
                                                                                (str("port-statistics") | str("address-pool-utilization") | str("dhcpv4-server-stats") | str("thermal") | str("chassis-inventory") | str("chassis-power") | str("resource-utilization") | str("uptime") | str("subscriber-statistics") | str("interface-metadata"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("input-ipfix"),
                                                          c(
                                                              b(str("parameters"),
                                                                  c(
                                                                      a(str("tcp-port"), arg),
                                                                      a(str("maximum-connections"), arg),
                                                                      a(str("vrf-name"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("analytics"),
                                                          c(
                                                              b(str("parameters"),
                                                                  c(
                                                                      a(str("sample-frequency"), arg),
                                                                      a(str("sensors"), arg),
                                                                      str("generate-tags")
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("outputs"),
                                                output_plugin
                                              )
                                          )
                                      ),
                                      b(str("traceoptions"),
                                          c(
                                              b(str("flag"),
                                                (str("trace") | str("debug") | str("info") | str("error"))
                                              ),
                                              arg
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("jinsightd"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("all") | str("rule-engine") | str("core") | str("database") | str("timer"))).as(:oneline)
                                  )
                              ),
                              b(str("subscribe"),
                                  c(
                                      str("health-monitor")
                                  )
                              )
                          )
                      ),
                      b(str("fixed-wireless-access"),
                          c(
                              b(a(str("control-plane"), arg),
                                  c(
                                      b(str("s11"),
                                          c(
                                              b(str("v4-address"),
                                                ipv4addr
                                              ),
                                              b(str("path-management"),
                                                (str("enable") | str("disable"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("apn"), arg),
                                  c(
                                      a(str("description"), quote | arg),
                                      b(str("apn-data-type"),
                                        (str("ipv4"))
                                      ),
                                      a(str("aaa-profile"), arg),
                                      a(str("dynamic-profile"), arg),
                                      a(str("ipv4-address-pool"), arg),
                                      a(str("routing-instance"), arg),
                                      b(str("authentication"),
                                        fwa_authentication_type
                                      )
                                  )
                              ),
                              b(a(str("data-plane"), arg),
                                  c(
                                      b(str("s1-u"),
                                          c(
                                              b(str("v4-address"),
                                                ipv4addr
                                              )
                                          )
                                      )
                                  )
                              ),
                              a(str("anchor-point"), arg),
                              b(str("traceoptions"),
                                bbefwa_trace_options_type
                              )
                          )
                      ),
                      b(str("captive-portal-content-delivery"),
                          c(
                              a(str("auto-deactivate"), arg),
                              b(str("rule"),
                                cpcd_rule_object_type
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              ),
                              b(a(str("profile"), arg),
                                  c(
                                      c(
                                        str("dynamic"),
                                        a(str("cpcd-rules"), arg),
                                        a(str("cpcd-rule-sets"), arg)
                                      ),
                                      b(str("ipda-rewrite-options"),
                                          c(
                                              b(str("destination-address"),
                                                ipaddr
                                              ),
                                              a(str("destination-port"), arg)
                                          )
                                      ),
                                      b(str("http-redirect-options"),
                                          c(
                                              arg
                                          )
                                      ),
                                      b(str("auto-deactivate"),
                                        (str("never") | str("initial-get"))
                                      )
                                  )
                              ),
                              b(str("traceoptions"),
                                cpcd_trace_options_type
                              )
                          )
                      ),
                      b(str("dynamic-flow-capture"),
                          c(
                              a(str("g-max-duplicates"), arg),
                              a(str("g-duplicates-dropped-periodicity"), arg),
                              b(str("capture-group"),
                                dfc_group_type
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("flow-tap"),
                          c(
                              b(str("family"),
                                  c(
                                      str("inet6"),
                                      str("inet"),
                                      str("ccc")
                                  )
                              ),
                              b(str("interface"),
                                interface_name
                              ),
                              b(str("tunnel-interface"),
                                interface_name
                              )
                          )
                      ),
                      b(str("radius-flow-tap"),
                          c(
                              a(str("forwarding-class"), arg),
                              b(str("source-ipv4-address"),
                                ipv4addr
                              ),
                              str("multicast-interception"),
                              b(str("interfaces"),
                                  c(
                                        tunnel_interface_type
                                  )
                              ),
                              c(
                                a(str("routing-instance"), arg),
                                b(a(str("logical-system"), arg),
                                    c(
                                        a(str("routing-instance"), arg)
                                    )
                                )
                              ),
                              b(a(str("policy"), arg),
                                  c(
                                      b(str("inet"),
                                          c(
                                              b(str("drop-policy"),
                                                drop_policy_term
                                              )
                                          )
                                      ),
                                      b(str("inet6"),
                                          c(
                                              b(str("drop-policy"),
                                                drop_policy6_term
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("snmp"),
                                  c(
                                      a(str("notify-targets"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("mobile-flow-tap"),
                          c(
                              b(str("source-interface"),
                                  sc(
                                        interface_name,
                                      b(str("ipv4-address"),
                                        ipv4addr
                                      )
                                  )
                              ).as(:oneline)
                          )
                      ),
                      b(str("flow-monitoring"),
                          c(
                              b(str("version9"),
                                  c(
                                      b(str("template"),
                                        version9_template
                                      )
                                  )
                              ),
                              b(str("version-ipfix"),
                                  c(
                                      b(str("template"),
                                        version_ipfix_template
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("jdaf"),
                          c(
                              a(str("routing-instances"), arg)
                          )
                      ),
                      b(str("rpm"),
                          c(
                              b(str("traceoptions"),
                                rmopd_traceoptions
                              ),
                              b(str("bgp"),
                                  c(
                                      b(str("probe-type"),
                                        (str("icmp-ping") | str("icmp-ping-timestamp") | str("icmp6-ping") | str("tcp-ping") | str("udp-ping") | str("udp-ping-timestamp"))
                                      ),
                                      a(str("probe-count"), arg),
                                      a(str("probe-interval"), arg),
                                      a(str("test-interval"), arg),
                                      a(str("destination-port"), arg),
                                      a(str("history-size"), arg),
                                      a(str("moving-average-size"), arg),
                                      a(str("data-size"), arg),
                                      a(str("data-fill"), arg),
                                      a(str("ttl"), arg),
                                      b(str("logical-system"),
                                        bgp_logical_system
                                      ),
                                      b(str("routing-instances"),
                                        bgp_routing_instances
                                      )
                                  )
                              ),
                              b(a(str("probe"), arg),
                                  c(
                                      str("delegate-probes"),
                                      b(a(str("test"), arg),
                                          c(
                                              b(str("rpm-scale"),
                                                  c(
                                                      a(str("tests-count"), arg),
                                                      c(
                                                        b(str("target"),
                                                            c(
                                                                b(str("address-base"),
                                                                  ipv4addr
                                                                ),
                                                                b(str("step"),
                                                                  ipv4addr
                                                                ),
                                                                a(str("count"), arg)
                                                            )
                                                        ),
                                                        b(str("target-inet6"),
                                                            c(
                                                                b(str("address-base"),
                                                                  ipv6addr
                                                                ),
                                                                b(str("step"),
                                                                  ipv6addr
                                                                ),
                                                                a(str("count"), arg)
                                                            )
                                                        )
                                                      ),
                                                      c(
                                                        b(str("source"),
                                                            c(
                                                                b(str("address-base"),
                                                                  ipv4addr
                                                                ),
                                                                b(str("step"),
                                                                  ipv4addr
                                                                ),
                                                                a(str("count"), arg)
                                                            )
                                                        ),
                                                        b(str("source-inet6"),
                                                            c(
                                                                b(str("address-base"),
                                                                  ipv6addr
                                                                ),
                                                                b(str("step"),
                                                                  ipv6addr
                                                                ),
                                                                a(str("count"), arg)
                                                            )
                                                        )
                                                      ),
                                                      b(str("destination"),
                                                          c(
                                                              b(str("interface"),
                                                                interface_name
                                                              ),
                                                              a(str("subunit-cnt"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("probe-type"),
                                                (str("http-get") | str("http-metadata-get") | str("icmp-ping") | str("icmp-ping-timestamp") | str("icmp6-ping") | str("tcp-ping") | str("udp-ping") | str("udp-ping-timestamp"))
                                              ),
                                              b(str("target"),
                                                  sc(
                                                      c(
                                                        b(str("address"),
                                                          ipv4addr
                                                        ),
                                                        b(str("inet6-address"),
                                                          ipv6addr
                                                        ),
                                                        a(str("url"), arg),
                                                        a(str("inet6-url"), arg)
                                                      )
                                                  )
                                              ).as(:oneline),
                                              b(str("inet6-options"),
                                                  c(
                                                      b(str("source-address"),
                                                        ipv6addr
                                                      )
                                                  )
                                              ),
                                              a(str("probe-count"), arg),
                                              a(str("probe-interval"), arg),
                                              a(str("test-interval"), arg),
                                              a(str("destination-port"), arg),
                                              b(str("source-address"),
                                                ipv4addr
                                              ),
                                              a(str("routing-instance"), arg),
                                              a(str("history-size"), arg),
                                              a(str("moving-average-size"), arg),
                                              a(str("dscp-code-points"), arg),
                                              a(str("data-size"), arg),
                                              a(str("data-fill"), arg),
                                              a(str("ttl"), arg),
                                              b(str("thresholds"),
                                                  c(
                                                      a(str("successive-loss"), arg),
                                                      a(str("total-loss"), arg),
                                                      a(str("rtt"), arg),
                                                      a(str("jitter-rtt"), arg),
                                                      a(str("std-dev-rtt"), arg),
                                                      a(str("egress-time"), arg),
                                                      a(str("ingress-time"), arg),
                                                      a(str("jitter-ingress"), arg),
                                                      a(str("jitter-egress"), arg),
                                                      a(str("std-dev-ingress"), arg),
                                                      a(str("std-dev-egress"), arg)
                                                  )
                                              ),
                                              b(str("traps"),
                                                (str("probe-failure") | str("test-failure") | str("test-completion") | str("rtt-exceeded") | str("std-dev-exceeded") | str("jitter-exceeded") | str("ingress-time-exceeded") | str("ingress-std-dev-exceeded") | str("ingress-jitter-exceeded") | str("egress-time-exceeded") | str("egress-std-dev-exceeded") | str("egress-jitter-exceeded"))
                                              ),
                                              b(str("destination-interface"),
                                                interface_name
                                              ),
                                              str("hardware-timestamp"),
                                              str("one-way-hardware-timestamp"),
                                              b(str("next-hop"),
                                                ipv4addr
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("probe-server"),
                                  c(
                                      b(str("icmp"),
                                          c(
                                              b(str("destination-interface"),
                                                interface_name
                                              )
                                          )
                                      ),
                                      b(str("tcp"),
                                          c(
                                              a(str("port"), arg),
                                              b(str("destination-interface"),
                                                interface_name
                                              )
                                          )
                                      ),
                                      b(str("udp"),
                                          c(
                                              a(str("port"), arg),
                                              b(str("destination-interface"),
                                                interface_name
                                              )
                                          )
                                      )
                                  )
                              ),
                              a(str("probe-limit"), arg),
                              b(str("rfc2544-benchmarking"),
                                  c(
                                      b(str("profiles"),
                                          c(
                                              b(a(str("test-profile"), arg),
                                                  c(
                                                      b(str("test-type"),
                                                        (str("throughput") | str("latency") | str("frame-loss") | str("back-back-frames"))
                                                      ),
                                                      a(str("packet-size"), arg),
                                                      a(str("bandwidth-kbps"), arg),
                                                      a(str("step-percent"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("tests"),
                                          c(
                                              b(a(str("test-name"), arg),
                                                  c(
                                                      a(str("test-profile"), arg),
                                                      b(str("source-mac-address"),
                                                        mac_unicast
                                                      ),
                                                      b(str("destination-mac-address"),
                                                        mac_unicast
                                                      ),
                                                      a(str("ovlan-id"), arg),
                                                      a(str("ovlan-priority"), arg),
                                                      a(str("ovlan-cfi"), arg),
                                                      a(str("outer-tag-protocol-id"), arg),
                                                      a(str("ivlan-id"), arg),
                                                      a(str("ivlan-priority"), arg),
                                                      a(str("ivlan-cfi"), arg),
                                                      a(str("vlan-id"), arg),
                                                      a(str("vlan-priority"), arg),
                                                      a(str("vlan-cfi"), arg),
                                                      b(str("service-type"),
                                                        (str("eline") | str("elan"))
                                                      ),
                                                      str("in-service"),
                                                      str("ip-swap"),
                                                      str("udp-tcp-port-swap"),
                                                      str("ignore-test-interface-state"),
                                                      str("check-test-interface-mtu"),
                                                      str("disable-signature-check"),
                                                      a(str("forwarding-class"), arg),
                                                      b(str("packet-loss-priority"),
                                                        (str("low") | str("high") | str("medium-high"))
                                                      ),
                                                      a(str("dscp-code-points"), arg),
                                                      b(str("mode"),
                                                        (str("reflect") | str("initiate-and-terminate") | str("ethernet-loopback"))
                                                      ),
                                                      b(str("reflect-mode"),
                                                        (str("mac-swap") | str("no-mac-swap") | str("mac-rewrite"))
                                                      ),
                                                      b(str("family"),
                                                        (str("inet") | str("ccc") | str("bridge") | str("vpls"))
                                                      ),
                                                      a(str("reflect-etype"), arg),
                                                      b(str("direction"),
                                                        (str("ingress") | str("egress"))
                                                      ),
                                                      b(str("timestamp-format"),
                                                        (str("microseconds") | str("nanoseconds"))
                                                      ),
                                                      a(str("source-udp-port"), arg),
                                                      a(str("destination-udp-port"), arg),
                                                      a(str("test-duration"), arg),
                                                      a(str("test-iterator-duration"), arg),
                                                      a(str("test-finish-wait-duration"), arg),
                                                      a(str("transmit-failure-threshold"), arg),
                                                      a(str("receive-failure-threshold"), arg),
                                                      a(str("test-iterator-pass-threshold"), arg),
                                                      str("halt-on-prefix-down"),
                                                      str("skip-arp-iteration"),
                                                      b(str("test-interface"),
                                                        interface_name
                                                      ),
                                                      a(str("reflector-port"), arg),
                                                      b(str("destination-ipv4-address"),
                                                        ipv4addr
                                                      ),
                                                      b(str("source-ipv4-address"),
                                                        ipv4addr
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("twamp"),
                                  c(
                                      str("post-cli-implicit-firewall"),
                                      b(str("client"),
                                          c(
                                              b(a(str("control-connection"), arg),
                                                  c(
                                                      b(str("authentication-mode"),
                                                          c(
                                                              str("none")
                                                          )
                                                      ),
                                                      b(str("destination-interface"),
                                                        interface_name
                                                      ),
                                                      str("persistent-results"),
                                                      a(str("tcp-keepidle"), arg),
                                                      a(str("tcp-keepintvl"), arg),
                                                      a(str("tcp-keepcnt"), arg),
                                                      a(str("destination-port"), arg),
                                                      a(str("history-size"), arg),
                                                      a(str("moving-average-size"), arg),
                                                      a(str("routing-instance"), arg),
                                                      b(str("target-address"),
                                                        ipv4addr
                                                      ),
                                                      a(str("test-count"), arg),
                                                      a(str("test-interval"), arg),
                                                      b(str("traps"),
                                                          c(
                                                              str("test-iteration-done"),
                                                              str("control-connection-closed")
                                                          )
                                                      ),
                                                      b(a(str("test-session"), arg),
                                                          c(
                                                              b(str("target-address"),
                                                                ipv4addr
                                                              ),
                                                              str("data-fill-with-zeros"),
                                                              a(str("data-size"), arg),
                                                              a(str("dscp-code-points"), arg),
                                                              a(str("ttl"), arg),
                                                              a(str("probe-count"), arg),
                                                              a(str("probe-interval"), arg),
                                                              b(str("thresholds"),
                                                                  c(
                                                                      a(str("successive-loss"), arg),
                                                                      a(str("total-loss"), arg),
                                                                      a(str("rtt"), arg),
                                                                      a(str("max-rtt"), arg),
                                                                      a(str("jitter-rtt"), arg),
                                                                      a(str("std-dev-rtt"), arg),
                                                                      a(str("egress-time"), arg),
                                                                      a(str("ingress-time"), arg),
                                                                      a(str("jitter-ingress"), arg),
                                                                      a(str("jitter-egress"), arg),
                                                                      a(str("std-dev-ingress"), arg),
                                                                      a(str("std-dev-egress"), arg)
                                                                  )
                                                              ),
                                                              b(str("traps"),
                                                                  c(
                                                                      str("probe-failure"),
                                                                      str("test-failure"),
                                                                      str("test-completion"),
                                                                      str("rtt-exceeded"),
                                                                      str("max-rtt-exceeded"),
                                                                      str("std-dev-exceeded"),
                                                                      str("jitter-exceeded"),
                                                                      str("ingress-time-exceeded"),
                                                                      str("ingress-std-dev-exceeded"),
                                                                      str("ingress-jitter-exceeded"),
                                                                      str("egress-time-exceeded"),
                                                                      str("egress-std-dev-exceeded"),
                                                                      str("egress-jitter-exceeded")
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("server"),
                                          c(
                                              a(str("tcp-keepidle"), arg),
                                              a(str("tcp-keepintvl"), arg),
                                              a(str("tcp-keepcnt"), arg),
                                              b(a(str("routing-instance-list"), arg),
                                                  c(
                                                      a(str("port"), arg)
                                                  )
                                              ),
                                              b(str("authentication-mode"),
                                                  c(
                                                      str("none"),
                                                      b(str("authenticated"),
                                                          sc(
                                                              str("control-only")
                                                          )
                                                      ).as(:oneline),
                                                      b(str("encrypted"),
                                                          sc(
                                                              str("control-only")
                                                          )
                                                      ).as(:oneline),
                                                      str("control-only-encrypted")
                                                  )
                                              ),
                                              b(str("authentication-key-chain"),
                                                twamp_authentication_key_chain
                                              ),
                                              a(str("server-inactivity-timeout"), arg),
                                              a(str("max-connection-duration"), arg),
                                              a(str("maximum-sessions"), arg),
                                              a(str("maximum-sessions-per-connection"), arg),
                                              a(str("maximum-connections"), arg),
                                              a(str("maximum-connections-per-client"), arg),
                                              a(str("port"), arg),
                                              b(a(str("client-list"), arg),
                                                  c(
                                                      a(str("address"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("video-monitoring"),
                          c(
                              b(a(str("templates"), arg),
                                  c(
                                      a(str("interval-duration"), arg),
                                      a(str("inactive-timeout"), arg),
                                      b(str("rate"),
                                          c(
                                              c(
                                                a(str("media"), arg),
                                                a(str("layer3"), arg)
                                              )
                                          )
                                      ),
                                      b(str("delay-factor"),
                                          c(
                                              b(str("threshold"),
                                                  c(
                                                      a(str("info"), arg),
                                                      a(str("warning"), arg),
                                                      a(str("critical"), arg)
                                                  )
                                              ),
                                                (str("disable"))
                                          )
                                      ),
                                      b(str("media-loss-rate"),
                                          c(
                                              b(str("threshold"),
                                                  c(
                                                      b(str("info"),
                                                          c(
                                                              c(
                                                                b(str("packet-count"),
                                                                  unsigned_float
                                                                ),
                                                                a(str("percentage"), arg)
                                                              )
                                                          )
                                                      ),
                                                      b(str("warning"),
                                                          c(
                                                              c(
                                                                b(str("packet-count"),
                                                                  unsigned_float
                                                                ),
                                                                a(str("percentage"), arg)
                                                              )
                                                          )
                                                      ),
                                                      b(str("critical"),
                                                          c(
                                                              c(
                                                                b(str("packet-count"),
                                                                  unsigned_float
                                                                ),
                                                                a(str("percentage"), arg)
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                                (str("disable"))
                                          )
                                      ),
                                      b(str("media-rate-variation"),
                                          c(
                                              b(str("threshold"),
                                                  c(
                                                      a(str("info"), arg),
                                                      a(str("warning"), arg),
                                                      a(str("critical"), arg)
                                                  )
                                              ),
                                                (str("disable"))
                                          )
                                      ),
                                      a(str("media-packets-count-in-layer3"), arg),
                                      a(str("media-packet-size"), arg)
                                  )
                              ),
                              b(a(str("interfaces"), arg),
                                  c(
                                      b(str("family"),
                                          c(
                                              b(str("inet"),
                                                  c(
                                                      b(a(str("input-flows"), arg),
                                                          c(
                                                              b(str("source-address"),
                                                                ipv4prefix
                                                              ),
                                                              b(str("destination-address"),
                                                                ipv4prefix
                                                              ),
                                                              a(str("source-port"), arg),
                                                              a(str("destination-port"), arg),
                                                              a(str("template"), arg)
                                                          )
                                                      ),
                                                      b(a(str("output-flows"), arg),
                                                          c(
                                                              b(str("source-address"),
                                                                ipv4prefix
                                                              ),
                                                              b(str("destination-address"),
                                                                ipv4prefix
                                                              ),
                                                              a(str("source-port"), arg),
                                                              a(str("destination-port"), arg),
                                                              a(str("template"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("inet6"),
                                                  c(
                                                      b(a(str("input-flows"), arg),
                                                          c(
                                                              b(str("source-address"),
                                                                ipv6prefix
                                                              ),
                                                              b(str("destination-address"),
                                                                ipv6prefix
                                                              ),
                                                              a(str("source-port"), arg),
                                                              a(str("destination-port"), arg),
                                                              a(str("template"), arg)
                                                          )
                                                      ),
                                                      b(a(str("output-flows"), arg),
                                                          c(
                                                              b(str("source-address"),
                                                                ipv6prefix
                                                              ),
                                                              b(str("destination-address"),
                                                                ipv6prefix
                                                              ),
                                                              a(str("source-port"), arg),
                                                              a(str("destination-port"), arg),
                                                              a(str("template"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("mpls"),
                                                  c(
                                                      b(a(str("input-flows"), arg),
                                                          c(
                                                              b(str("payload-type"),
                                                                (str("ipv4") | str("ipv6"))
                                                              ),
                                                              b(str("source-address"),
                                                                ipprefix
                                                              ),
                                                              b(str("destination-address"),
                                                                ipprefix
                                                              ),
                                                              a(str("source-port"), arg),
                                                              a(str("destination-port"), arg),
                                                              a(str("template"), arg)
                                                          )
                                                      ),
                                                      b(a(str("output-flows"), arg),
                                                          c(
                                                              b(str("payload-type"),
                                                                (str("ipv4") | str("ipv6"))
                                                              ),
                                                              b(str("source-address"),
                                                                ipprefix
                                                              ),
                                                              b(str("destination-address"),
                                                                ipprefix
                                                              ),
                                                              a(str("source-port"), arg),
                                                              a(str("destination-port"), arg),
                                                              a(str("template"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              a(str("stats-cache-life-time"), arg),
                              a(str("errors-cache-life-time"), arg),
                              a(str("flow-cache-life-time"), arg),
                              b(str("alarms"),
                                  c(
                                      b(str("delay-factor"),
                                          c(
                                              str("no-syslog-generation"),
                                              str("generate-snmp-traps"),
                                              b(str("storm-control"),
                                                  c(
                                                      a(str("count"), arg),
                                                      a(str("interval"), arg)
                                                  )
                                              ),
                                              b(str("alarm-mode"),
                                                  c(
                                                      a(str("mdi-records-count"), arg),
                                                      c(
                                                        str("immediate"),
                                                        str("average")
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("media-rate-variation"),
                                          c(
                                              str("no-syslog-generation"),
                                              str("generate-snmp-traps"),
                                              b(str("storm-control"),
                                                  c(
                                                      a(str("count"), arg),
                                                      a(str("interval"), arg)
                                                  )
                                              ),
                                              b(str("alarm-mode"),
                                                  c(
                                                      a(str("mdi-records-count"), arg),
                                                      c(
                                                        str("immediate"),
                                                        str("average")
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("media-loss-rate"),
                                          c(
                                              str("no-syslog-generation"),
                                              str("generate-snmp-traps"),
                                              b(str("storm-control"),
                                                  c(
                                                      a(str("count"), arg),
                                                      a(str("interval"), arg)
                                                  )
                                              ),
                                              b(str("alarm-mode"),
                                                  c(
                                                      a(str("mdi-records-count"), arg),
                                                      c(
                                                        str("immediate"),
                                                        str("average")
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("flow-insert"),
                                          c(
                                              str("no-syslog-generation"),
                                              str("generate-snmp-traps"),
                                              b(str("storm-control"),
                                                  c(
                                                      a(str("count"), arg),
                                                      a(str("interval"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("flow-delete"),
                                          c(
                                              str("no-syslog-generation"),
                                              str("generate-snmp-traps"),
                                              b(str("storm-control"),
                                                  c(
                                                      a(str("count"), arg),
                                                      a(str("interval"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("stats-timeout"),
                          c(
                              a(str("stats-timeout-value"), arg)
                          )
                      ),
                      b(str("app-engine"),
                          c(
                              str("security"),
                              b(str("monitor-cpu"),
                                monitor_threshold
                              ),
                              b(str("monitor-memory"),
                                monitor_threshold
                              ),
                              b(str("monitor-storage"),
                                monitor_threshold
                              ),
                              a(str("default-compute-node-package"), arg),
                              b(a(str("compute-cluster"), arg),
                                  c(
                                      b(str("local-management"),
                                          c(
                                              b(str("routing-instance"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("family"),
                                                          c(
                                                              b(str("inet"),
                                                                  c(
                                                                      b(str("address"),
                                                                        ipv4addr
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              ),
                                              b(str("family"),
                                                  c(
                                                      b(str("inet"),
                                                          c(
                                                              b(str("address"),
                                                                ipv4addr
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("monitor-cpu"),
                                        monitor_threshold
                                      ),
                                      b(str("monitor-memory"),
                                        monitor_threshold
                                      ),
                                      b(str("monitor-storage"),
                                        monitor_threshold
                                      ),
                                      b(a(str("compute-node"), arg),
                                          c(
                                              b(str("monitor-cpu"),
                                                monitor_threshold
                                              ),
                                              b(str("monitor-memory"),
                                                monitor_threshold
                                              ),
                                              b(str("monitor-storage"),
                                                monitor_threshold
                                              ),
                                              c(
                                                b(str("mac-address"),
                                                  mac_addr
                                                ),
                                                a(str("fpc"), arg),
                                                str("hypervisor")
                                              ),
                                              a(str("package"), arg),
                                              b(str("routing-options"),
                                                  c(
                                                      b(str("static"),
                                                          c(
                                                              b(a(str("route"), arg),
                                                                  c(
                                                                      b(str("next-hop"),
                                                                        ipv4addr
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(a(str("rib"), arg),
                                                          c(
                                                              b(str("static"),
                                                                  c(
                                                                      b(a(str("route"), arg),
                                                                          c(
                                                                              b(str("next-hop"),
                                                                                ipv4addr
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("interfaces"),
                                                  c(
                                                      b(a(str("ethernet"), arg),
                                                          c(
                                                              str("management"),
                                                              b(str("family"),
                                                                family
                                                              ),
                                                              str("enable-passthrough"),
                                                              a(str("mtu"), arg),
                                                              b(str("ether-options"),
                                                                  c(
                                                                      c(
                                                                        a(str("ieee-802-3ad"), arg)
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(a(str("bridge"), arg),
                                                          c(
                                                              str("management"),
                                                              b(str("family"),
                                                                family
                                                              ),
                                                              a(str("interface"), arg),
                                                              a(str("mtu"), arg)
                                                          )
                                                      ),
                                                      b(a(str("aggregate"), arg),
                                                          c(
                                                              str("management"),
                                                              b(str("family"),
                                                                family
                                                              ),
                                                              a(str("mtu"), arg),
                                                              b(str("aggregated-ether-options"),
                                                                  c(
                                                                      b(str("hash-policy"),
                                                                        (str("layer-2") | str("layer-3-and-4") | str("layer-2-and-3"))
                                                                      ),
                                                                      a(str("miimon"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              a(str("syslog"), enum(str("any") | str("authorization") | str("privileged") | str("cron") | str("daemon") | str("kernel") | str("syslog") | str("user") | str("uucp") | str("local0") | str("local1") | str("local2") | str("local3") | str("local4") | str("local5") | str("local6") | str("local7")),
                                                  sc(
                                                      c(
                                                        str("any"),
                                                        str("emergency"),
                                                        str("alert"),
                                                        str("critical"),
                                                        str("error"),
                                                        str("warning"),
                                                        str("notice"),
                                                        str("info"),
                                                        str("debug")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ),
                              b(str("virtual-machines"),
                                  c(
                                      b(a(str("instance"), arg),
                                          c(
                                              a(str("cpu"), arg),
                                              a(str("memory"), arg),
                                              a(str("management-interface"), arg),
                                              a(str("package"), arg),
                                              b(str("local-management"),
                                                  c(
                                                      b(str("routing-instance"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("family"),
                                                                  c(
                                                                      b(str("inet"),
                                                                          c(
                                                                              b(str("address"),
                                                                                ipv4addr
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      ),
                                                      b(str("family"),
                                                          c(
                                                              b(str("inet"),
                                                                  c(
                                                                      b(str("address"),
                                                                        ipv4addr
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(a(str("compute-cluster"), arg),
                                                  c(
                                                      a(str("compute-node"), arg)
                                                  )
                                              ),
                                              b(a(str("interface"), arg),
                                                  c(
                                                      b(str("hw-model"),
                                                        (str("e1000g") | str("virtio"))
                                                      ),
                                                      a(str("host-interface"), arg),
                                                      a(str("bridge"), arg),
                                                      a(str("mtu"), arg),
                                                      b(str("family"),
                                                          c(
                                                              b(str("inet"),
                                                                  c(
                                                                      b(a(str("address"), arg),
                                                                          c(
                                                                              str("primary")
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("routing-options"),
                                                  c(
                                                      b(str("static"),
                                                          c(
                                                              b(a(str("route"), arg),
                                                                  c(
                                                                      b(str("next-hop"),
                                                                        ipv4addr
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(a(str("rib"), arg),
                                                          c(
                                                              b(str("static"),
                                                                  c(
                                                                      b(a(str("route"), arg),
                                                                          c(
                                                                              b(str("next-hop"),
                                                                                ipv4addr
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              a(str("secondary-disk"), str("hdb") | str("hdc") | str("hdd"),
                                                  sc(
                                                      a(str("size"), arg)
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("unified-access-control"),
                          c(
                              b(a(str("infranet-controller"), arg),
                                  c(
                                      b(str("address"),
                                        ipv4addr
                                      ),
                                      a(str("port"), arg),
                                      b(str("interface"),
                                        interface_name
                                      ),
                                      a(str("password"), arg),
                                      a(str("ca-profile"), arg),
                                      a(str("server-certificate-subject"), arg)
                                  )
                              ),
                              b(str("certificate-verification"),
                                (str("warning") | str("required") | str("optional"))
                              ),
                              a(str("timeout"), arg),
                              a(str("interval"), arg),
                              b(str("timeout-action"),
                                (str("close") | str("no-change") | str("open"))
                              ),
                              str("test-only-mode"),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("all") | str("ipc") | str("config") | str("connect"))).as(:oneline)
                                  )
                              ),
                              b(a(str("captive-portal"), arg),
                                  c(
                                      b(str("redirect-traffic"),
                                        (str("unauthenticated") | str("all"))
                                      ),
                                      a(str("redirect-url"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("flow-collector"),
                          c(
                              b(str("analyzer-address"),
                                ipv4addr
                              ),
                              a(str("analyzer-id"), arg),
                              a(str("retry"), arg),
                              a(str("retry-delay"), arg),
                              b(str("destinations"),
                                collector_destinations_type
                              ),
                              b(str("file-specification"),
                                file_specification_type
                              ),
                              b(str("interface-map"),
                                interface_map_type
                              ),
                              b(str("transfer-log-archive"),
                                collector_transfer_log_archive_type
                              )
                          )
                      ),
                      b(str("captive-portal"),
                        juniper_services_captive_portal
                      ),
                      b(str("logging"),
                        juniper_pic_services_logging_options
                      ),
                      b(str("application-identification"),
                          c(
                              str("enable-heuristics"),
                              b(str("enable-performance-mode"),
                                  c(
                                      a(str("max-packet-threshold"), arg)
                                  )
                              ),
                              a(str("imap-cache-timeout"), arg),
                              a(str("imap-cache-size"), arg),
                              b(str("download"),
                                  c(
                                      a(str("url"), arg),
                                      str("ignore-server-validation"),
                                      b(str("automatic"),
                                          c(
                                              a(str("start-time"), arg),
                                              a(str("interval"), arg)
                                          )
                                      ),
                                      a(str("proxy-profile"), arg)
                                  )
                              ),
                              b(str("statistics"),
                                  c(
                                      a(str("interval"), arg)
                                  )
                              ),
                              b(str("nested-application-settings"),
                                  c(
                                      str("no-nested-application"),
                                      str("no-application-system-cache")
                                  )
                              ),
                              str("no-application-identification"),
                              str("no-signature-based"),
                              str("no-protocol-based"),
                              str("signature-method-all-ports"),
                              str("no-clear-application-system-cache"),
                              str("no-application-system-cache"),
                              a(str("max-sessions"), arg),
                              a(str("application-system-cache-timeout"), arg),
                              b(str("application-system-cache"),
                                  c(
                                      str("security-services"),
                                      str("no-miscellaneous-services")
                                  )
                              ),
                              str("micro-apps"),
                              a(str("max-transactions"), arg),
                              a(str("max-memory"), arg),
                              a(str("max-checked-bytes"), arg),
                              b(a(str("application"), arg),
                                  c(
                                      a(str("type"), arg),
                                      a(str("index"), arg),
                                      b(a(str("tags"), arg),
                                          c(
                                              arg
                                          )
                                      ),
                                      b(str("session-timeout"),
                                        (str("0") | str("30") | str("60") | str("1800") | str("3600") | str("43200") | str("86400") | str("2592000"))
                                      ),
                                      b(str("idle-timeout"),
                                        (str("0") | str("5") | str("15") | str("30") | str("60") | str("1800") | str("3600"))
                                      ),
                                      b(str("type-of-service"),
                                          c(
                                              str("minimize-delay"),
                                              str("maximize-throughput"),
                                              str("maximize-reliability"),
                                              str("minimize-monetary-cost")
                                          )
                                      ),
                                      str("disable"),
                                      str("cacheable"),
                                      a(str("risk"), arg),
                                      a(str("description"), quote | arg),
                                      b(str("priority"),
                                        (str("high") | str("low"))
                                      ),
                                      a(str("order"), arg),
                                      a(str("maximum-transactions"), arg),
                                      a(str("alt-name"), arg),
                                      a(str("compatibility"), arg),
                                      b(str("port-mapping"),
                                          c(
                                              b(str("icmp"),
                                                  c(
                                                      a(str("type"), arg),
                                                      a(str("code"), arg)
                                                  )
                                              ),
                                              a(str("protocol"), arg),
                                              b(str("port-range"),
                                                  c(
                                                      a(str("tcp"), arg),
                                                      a(str("udp"), arg)
                                                  )
                                              ),
                                              str("disable")
                                          )
                                      ),
                                      b(str("icmp-mapping"),
                                          c(
                                              a(str("type"), arg),
                                              a(str("code"), arg),
                                              a(str("order"), arg),
                                              b(str("order-priority"),
                                                (str("high") | str("low"))
                                              )
                                          )
                                      ),
                                      b(str("ip-protocol-mapping"),
                                          c(
                                              a(str("protocol"), arg),
                                              a(str("order"), arg),
                                              b(str("order-priority"),
                                                (str("high") | str("low"))
                                              )
                                          )
                                      ),
                                      b(a(str("address-mapping"), arg),
                                          c(
                                              b(str("filter"),
                                                  c(
                                                      b(str("ip"),
                                                        ipprefix
                                                      ),
                                                      b(str("port-range"),
                                                          c(
                                                              a(str("tcp"), arg),
                                                              a(str("udp"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("source"),
                                                  c(
                                                      b(str("ip"),
                                                        ipprefix
                                                      ),
                                                      b(str("wildcard-address"),
                                                          sc(
                                                              b(str("wildcard-mask"),
                                                                ipaddr
                                                              ),
                                                                ipaddr
                                                          )
                                                      ).as(:oneline),
                                                      b(str("port-range"),
                                                          c(
                                                              a(str("tcp"), arg),
                                                              a(str("udp"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("destination"),
                                                  c(
                                                      b(str("ip"),
                                                        ipprefix
                                                      ),
                                                      b(str("wildcard-address"),
                                                          sc(
                                                              b(str("wildcard-mask"),
                                                                ipaddr
                                                              ),
                                                                ipaddr
                                                          )
                                                      ).as(:oneline),
                                                      b(str("port-range"),
                                                          c(
                                                              a(str("tcp"), arg),
                                                              a(str("udp"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              a(str("order"), arg),
                                              b(str("order-priority"),
                                                (str("high") | str("low"))
                                              )
                                          )
                                      ),
                                      b(a(str("over"), arg),
                                          c(
                                              b(str("protocol"),
                                                (str("http") | str("ssl") | str("udp") | str("tcp"))
                                              ),
                                              str("chain-order"),
                                              b(str("order-priority"),
                                                (str("high") | str("low"))
                                              ),
                                              a(str("order"), arg),
                                              b(str("port-range"),
                                                  c(
                                                      a(str("tcp"), arg),
                                                      a(str("udp"), arg)
                                                  )
                                              ),
                                              b(a(str("member"), arg),
                                                  c(
                                                      a(str("context"), arg),
                                                      a(str("pattern"), arg),
                                                      b(str("direction"),
                                                        (str("client-to-server") | str("server-to-client") | str("any"))
                                                      ),
                                                      a(str("check-bytes"), arg)
                                                  )
                                              ),
                                              b(a(str("signature"), arg),
                                                  c(
                                                      a(str("port-range"), arg),
                                                      b(a(str("member"), arg),
                                                          c(
                                                              a(str("context"), arg),
                                                              a(str("pattern"), arg),
                                                              b(str("direction"),
                                                                (str("client-to-server") | str("server-to-client") | str("any"))
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("nested-application"), arg),
                                  c(
                                      a(str("type"), arg),
                                      a(str("index"), arg),
                                      a(str("protocol"), arg),
                                      b(a(str("signature"), arg),
                                          c(
                                              b(a(str("member"), arg),
                                                  c(
                                                      a(str("context"), arg),
                                                      a(str("pattern"), arg),
                                                      b(str("direction"),
                                                        (str("client-to-server") | str("server-to-client") | str("any"))
                                                      ),
                                                      a(str("check-bytes"), arg)
                                                  )
                                              ),
                                              str("chain-order"),
                                              a(str("maximum-transactions"), arg),
                                              a(str("order"), arg),
                                              b(str("insert-before"),
                                                  c(
                                                      arg
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("application-group"), arg),
                                  c(
                                      a(str("application-groups"), arg),
                                      a(str("applications"), arg),
                                      str("disable")
                                  )
                              ),
                              b(a(str("rule"), arg),
                                  c(
                                      a(str("application-name"), arg),
                                      b(a(str("address"), arg),
                                          c(
                                              b(str("source"),
                                                  c(
                                                      b(str("ip"),
                                                        ipv4prefix
                                                      ),
                                                      b(str("port-range"),
                                                          c(
                                                              a(str("tcp"), arg),
                                                              a(str("udp"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("destination"),
                                                  c(
                                                      b(str("ip"),
                                                        ipv4prefix
                                                      ),
                                                      b(str("port-range"),
                                                          c(
                                                              a(str("tcp"), arg),
                                                              a(str("udp"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              a(str("order"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              ),
                              b(a(str("profile"), arg),
                                  c(
                                      a(str("rule-set"), arg)
                                  )
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("all"))).as(:oneline),
                                      b(str("level"),
                                        (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                      )
                                  )
                              ),
                              b(str("inspection-limit"),
                                  c(
                                      b(str("tcp"),
                                          c(
                                              a(str("byte-limit"), arg),
                                              a(str("packet-limit"), arg)
                                          )
                                      ),
                                      b(str("udp"),
                                          c(
                                              a(str("byte-limit"), arg),
                                              a(str("packet-limit"), arg)
                                          )
                                      )
                                  )
                              ),
                              a(str("global-offload-byte-limit"), arg)
                          )
                      ),
                      b(a(str("service-set"), arg),
                          c(
                              b(str("syslog"),
                                log_object
                              ),
                              a(str("max-flows"), arg),
                              a(str("hosted-service-identifier"), arg),
                              a(str("max-session-setup-rate"), arg),
                              b(str("max-drop-flows"),
                                  c(
                                      a(str("ingress"), arg),
                                      a(str("egress"), arg)
                                  )
                              ),
                              b(str("snmp-trap-thresholds"),
                                  c(
                                      b(str("flow"),
                                          sc(
                                              a(str("low"), arg),
                                              a(str("high"), arg)
                                          )
                                      ).as(:oneline),
                                      b(str("nat-address-port"),
                                          sc(
                                              a(str("low"), arg),
                                              a(str("high"), arg)
                                          )
                                      ).as(:oneline),
                                      b(str("session"),
                                          sc(
                                              a(str("low"), arg),
                                              a(str("high"), arg)
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              a(str("tcp-mss"), arg),
                              b(str("cos-options"),
                                  c(
                                      str("match-rules-on-reverse-flow")
                                  )
                              ),
                              b(str("softwire-options"),
                                  c(
                                      b(str("dslite-ipv6-prefix-length"),
                                        (str("56") | str("64") | str("96") | str("128"))
                                      )
                                  )
                              ),
                              b(str("nat-options"),
                                  c(
                                      b(str("stateful-nat64"),
                                          c(
                                              str("clear-dont-fragment-bit"),
                                              a(str("ipv6-mtu"), arg),
                                              str("disable-h323-ras")
                                          )
                                      ),
                                      b(str("nptv6"),
                                          c(
                                              str("icmpv6-error-messages")
                                          )
                                      ),
                                      b(str("land-attack-check"),
                                        (str("ip-only") | str("ip-port"))
                                      ),
                                      a(str("max-sessions-per-subscriber"), arg),
                                      str("snmp-value-match-msmic")
                                  )
                              ),
                              b(str("service-set-options"),
                                  c(
                                      b(str("tcp-non-syn"),
                                        (str("drop-flow") | str("drop-flow-send-rst"))
                                      ),
                                      b(str("tcp-fast-open"),
                                        (str("disabled") | str("drop"))
                                      ),
                                      str("bypass-traffic-on-pic-failure"),
                                      str("bypass-traffic-on-exceeding-flow-limits"),
                                      str("enable-asymmetric-traffic-processing"),
                                      str("subscriber-awareness"),
                                      b(str("header-integrity-check"),
                                          c(
                                              str("enable-all")
                                          )
                                      ),
                                      str("disable-session-open-syslog"),
                                      str("enable-change-on-ams-redistribution"),
                                      str("routing-engine-services"),
                                      a(str("inactivity-non-tcp-timeout"), arg),
                                      a(str("session-timeout"), arg),
                                      b(str("session-limit"),
                                          c(
                                              a(str("maximum"), arg)
                                          )
                                      ),
                                      a(str("max-sessions-per-subscriber"), arg),
                                      b(str("tcp-session"),
                                          c(
                                              a(str("tcp-mss"), arg),
                                              a(str("tcp-tickles"), arg),
                                              a(str("open-timeout"), arg),
                                              a(str("inactivity-tcp-timeout"), arg),
                                              a(str("inactivity-asymm-tcp-timeout"), arg),
                                              b(str("ignore-errors"),
                                                  sc(
                                                      str("tcp")
                                                  )
                                              ).as(:oneline),
                                              a(str("close-timeout"), arg),
                                              b(str("tcp-non-syn"),
                                                (str("drop-flow") | str("drop-flow-send-rst"))
                                              ),
                                              b(str("tcp-fast-open"),
                                                (str("disabled") | str("drop"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("replicate-services"),
                                  c(
                                      a(str("replication-threshold"), arg),
                                      str("disable-replication-capability")
                                  )
                              ),
                              str("allow-multicast"),
                              c(
                                a(str("softwire-rules"), arg),
                                a(str("softwire-rule-sets"), arg)
                              ),
                              a(str("softwires-rule-set"), arg),
                              c(
                                a(str("stateful-firewall-rules"), arg),
                                a(str("stateful-firewall-rule-sets"), arg)
                              ),
                              c(
                                a(str("ids-option"), arg)
                              ),
                              c(
                                a(str("pcp-rules"), arg),
                                a(str("pcp-rule-sets"), arg)
                              ),
                              a(str("appid-profile"), arg),
                              c(
                                a(str("nat-rules"), arg),
                                a(str("nat-rule-sets"), arg)
                              ),
                              c(
                                a(str("ip-reassembly-rules"), arg)
                              ),
                              c(
                                a(str("ids-rules"), arg),
                                a(str("ids-rule-sets"), arg)
                              ),
                              c(
                                a(str("cos-rules"), arg),
                                a(str("cos-rule-sets"), arg)
                              ),
                              c(
                                a(str("aacl-rules"), arg),
                                a(str("aacl-rule-sets"), arg)
                              ),
                              a(str("aacl-dyn-rules"), arg),
                              c(
                                a(str("pgcp-rules"), arg),
                                a(str("pgcp-rule-sets"), arg)
                              ),
                              b(str("jflow-rules"),
                                  c(
                                      b(str("sampling"),
                                          c(
                                              a(str("instance"), arg)
                                          )
                                      )
                                  )
                              ),
                              c(
                                a(str("application-identification-profile"), arg)
                              ),
                              a(str("pcef-profile"), arg),
                              a(str("lrf-profile"), arg),
                              a(str("hcm-profile"), arg),
                              a(str("web-filter-profile"), arg),
                              c(
                                a(str("hcm-url-rules"), arg),
                                a(str("hcm-url-rule-sets"), arg)
                              ),
                              c(
                                a(str("tag-rules"), arg),
                                a(str("tag-rule-sets"), arg)
                              ),
                              c(
                                a(str("idp-profile"), arg)
                              ),
                              c(
                                a(str("captive-portal-content-delivery-profile"), arg)
                              ),
                              c(
                                b(str("policy-decision-statistics-profile"),
                                    c(
                                          arg
                                    )
                                )
                              ),
                              c(
                                b(str("interface-service"),
                                    c(
                                        b(str("service-interface"),
                                          interface_unit
                                        ),
                                        b(str("load-balancing-options"),
                                            c(
                                                b(str("hash-keys"),
                                                    c(
                                                        str("resource-triggered"),
                                                        b(str("ingress-key"),
                                                              enum((str("source-ip") | str("destination-ip") | str("protocol") | str("iif")))
                                                        ),
                                                        b(str("egress-key"),
                                                              enum((str("source-ip") | str("destination-ip") | str("protocol") | str("oif")))
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                ),
                                b(str("sampling-service"),
                                    c(
                                        b(str("service-interface"),
                                          interface_unit
                                        )
                                    )
                                ),
                                b(str("next-hop-service"),
                                    c(
                                        b(str("inside-service-interface"),
                                          interface_unit
                                        ),
                                        b(str("outside-service-interface"),
                                          interface_unit
                                        ),
                                        b(str("outside-service-interface-type"),
                                          (str("local"))
                                        ),
                                        a(str("service-interface-pool"), arg)
                                    )
                                )
                              ),
                              a(str("extension-service"), arg),
                              b(str("service-order"),
                                  c(
                                      a(str("forward-flow"), arg),
                                      a(str("reverse-flow"), arg)
                                  )
                              ),
                              b(str("jflow-log"),
                                  c(
                                      a(str("template-profile"), arg)
                                  )
                              ),
                              b(str("ipsec-vpn-options"),
                                service_set_ipsec_vpn_options_object
                              ),
                              c(
                                a(str("ipsec-vpn-rules"), arg),
                                a(str("ipsec-vpn-rule-sets"), arg)
                              ),
                              a(str("ipsec-group-vpn"), arg),
                              a(str("redundancy-set-id"), arg)
                          )
                      ),
                      b(str("ipsec-vpn"),
                          c(
                              b(str("rule"),
                                ipsec_vpn_rule_object
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              ),
                              b(str("ipsec"),
                                services_ipsec
                              ),
                              b(str("ike"),
                                services_ike
                              ),
                              b(str("traceoptions"),
                                ipsec_services_traceoptions
                              ),
                              str("no-ipsec-tunnel-in-traceroute"),
                              b(str("establish-tunnels"),
                                (str("immediately") | str("on-traffic") | str("responder-only"))
                              ),
                              str("clear-ike-sas-on-pic-restart"),
                              str("clear-ipsec-sas-on-pic-restart"),
                              str("disable-natt")
                          )
                      ),
                      b(str("lrf"),
                          c(
                              b(str("profile"),
                                lrf_profile_object
                              )
                          )
                      ),
                      b(str("pcef"),
                        services_pcef
                      ),
                      b(str("security-intelligence"),
                          c(
                              a(str("url"), arg),
                              b(str("authentication"),
                                  c(
                                      a(str("auth-token"), arg),
                                      a(str("tls-profile"), arg)
                                  )
                              ),
                              b(str("traceoptions"),
                                secintel_traceoptions
                              )
                          )
                      ),
                      b(str("ssl"),
                          c(
                              b(str("traceoptions"),
                                ssl_traceoptions
                              ),
                              b(str("termination"),
                                ssl_termination_config
                              ),
                              b(str("initiation"),
                                ssl_initiation_config
                              ),
                              b(str("proxy"),
                                ssl_proxy_config
                              )
                          )
                      ),
                      b(str("web-proxy"),
                          c(
                              b(str("traceoptions"),
                                web_proxy_traceoptions
                              ),
                              b(str("secure-proxy"),
                                web_config
                              )
                          )
                      ),
                      b(str("stateful-firewall"),
                          c(
                              b(str("rule"),
                                sfw_rule_object
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("ip-reassembly"),
                          c(
                              b(str("profile"),
                                ipr_profile_object
                              ),
                              b(str("rule"),
                                ipr_rule_object
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("softwire"),
                          c(
                              a(str("ipv6-multicast-interfaces"), str("all") | str("interface-name")),
                              b(str("softwire-concentrator"),
                                  c(
                                      b(str("ds-lite"),
                                        dslite_object
                                      ),
                                      b(str("v6rd"),
                                        v6rd_object
                                      ),
                                      b(str("map-e"),
                                        mape_object
                                      )
                                  )
                              ),
                              b(str("rule"),
                                sw_rule_object
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("aacl"),
                          c(
                              b(str("rule"),
                                aacl_rule_object
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              ),
                              b(a(str("aacl-dyn-rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("hcm"),
                          c(
                              b(str("url-rule"),
                                hcm_url_rule_object
                              ),
                              b(str("tag-rule"),
                                hcm_tag_rule_object
                              ),
                              b(str("url-list"),
                                hcm_url_list_object
                              ),
                              b(str("tag-attribute"),
                                    (str("msisdn") | str("imsi") | str("apn") | str("imei") | str("ipv4addr") | str("ipv6addr") | str("ggsnipv4") | str("ggsnipv6") | str("radiusclass"))
                              ),
                              b(a(str("url-rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              ),
                              b(a(str("tag-rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              ),
                              b(a(str("profile"), arg),
                                  c(
                                      b(str("tag-rule"),
                                          c(
                                              arg
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("cos"),
                        cos_object
                      ),
                      b(str("pgcp"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      b(str("flag"),
                                          c(
                                              b(str("default"),
                                                (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                              ),
                                              b(str("h248-stack"),
                                                  c(
                                                      b(str("default"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("control-association"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("media-gateway"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      str("messages")
                                                  )
                                              ),
                                              b(str("bgf-core"),
                                                  c(
                                                      b(str("default"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("firewall"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("gate-logic"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("policy"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("pic-broker"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("statistics"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("common"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      )
                                                  )
                                              ),
                                              b(str("sbc-utils"),
                                                  c(
                                                      b(str("default"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("common"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("configuration"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("device-monitor"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("ipc"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("memory-management"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("messaging"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      ),
                                                      b(str("user-interface"),
                                                        (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(str("media-service"),
                                pgcp_media_service_object
                              ),
                              b(str("virtual-interface"),
                                pgcp_virtual_interface_object
                              ),
                              b(str("gateway"),
                                pgcp_gateway_object
                              ),
                              b(str("rule"),
                                pgcp_rule_object
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              ),
                              b(str("session-mirroring"),
                                pgcp_session_mirroring_object
                              ),
                              a(str("notification-rate-limit"), arg)
                          )
                      ),
                      b(str("border-signaling-gateway"),
                          c(
                              b(str("gateway"),
                                gateway_type
                              )
                          )
                      ),
                      b(str("ids"),
                          c(
                              b(str("rule"),
                                ids_rule_object
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("nat"),
                        nat_object
                      ),
                      b(str("pcp"),
                          c(
                              b(str("server"),
                                pcp_server_object
                              ),
                              b(str("rule"),
                                pcp_rule_object
                              ),
                              b(a(str("rule-set"), arg),
                                  c(
                                      a(str("rule"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("l2tp"),
                          c(
                              b(str("tunnel-group"),
                                l2tp_tunnel_group_object
                              ),
                              b(str("ip-reassembly"),
                                  c(
                                      a(str("service-set"), arg)
                                  )
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      b(str("level"),
                                        (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                      ),
                                      a(str("flag"), enum(str("gres") | str("init") | str("events") | str("memory") | str("message") | str("packet-error") | str("parse") | str("receive-packets") | str("session-db") | str("states") | str("timer") | str("transmit-packets") | str("routing-socket") | str("routing-process") | str("protocol") | str("configuration") | str("ipc-tx") | str("ipc-rx") | str("general") | str("tunnel") | str("stats") | str("authentication") | str("all"))).as(:oneline),
                                      b(str("debug-level"),
                                        (str("error") | str("detail") | str("packet-dump"))
                                      ),
                                      b(str("filter"),
                                          c(
                                              a(str("protocol"), enum(str("ppp") | str("l2tp") | str("radius") | str("udp"))).as(:oneline),
                                              a(str("user-name"), arg),
                                              b(str("user"),
                                                  c(
                                                        arg
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("interfaces"),
                                        l2tp_interface_traceoptions
                                      )
                                  )
                              ),
                              str("weighted-load-balancing"),
                              str("destination-equal-load-balancing"),
                              str("drain"),
                              str("failover-within-preference"),
                              str("disable-calling-number-avp"),
                              str("disable-failover-protocol"),
                              str("rx-connect-speed-when-equal"),
                              b(str("tx-connect-speed-method"),
                                (str("none") | str("static") | str("ancp") | str("pppoe-ia-tag") | str("service-profile"))
                              ),
                              a(str("maximum-sessions"), arg),
                              b(str("tunnel"),
                                  c(
                                      b(a(str("name"), arg),
                                          sc(
                                              b(a(str("address"), arg),
                                                  sc(
                                                      b(a(str("routing-instance"), arg),
                                                          sc(
                                                              str("drain")
                                                          )
                                                      ).as(:oneline),
                                                      str("drain")
                                                  )
                                              ).as(:oneline),
                                              str("drain")
                                          )
                                      ).as(:oneline),
                                      b(str("assignment-id-format"),
                                        (str("assignment-id") | str("client-server-id"))
                                      ),
                                      a(str("retransmission-count-established"), arg),
                                      a(str("retransmission-count-not-established"), arg),
                                      b(str("nas-port-method"),
                                        (str("cisco-avp"))
                                      ),
                                      b(str("minimum-retransmission-timeout"),
                                        (str("1") | str("2") | str("4") | str("8") | str("16"))
                                      ),
                                      a(str("idle-timeout"), arg),
                                      a(str("rx-window-size"), arg),
                                      b(str("tx-address-change"),
                                          c(
                                              str("accept"),
                                              str("ignore"),
                                              str("ignore-ip-address"),
                                              str("ignore-udp-port"),
                                              str("reject"),
                                              str("reject-ip-address"),
                                              str("reject-udp-port")
                                          )
                                      ),
                                      a(str("maximum-sessions"), arg),
                                      b(str("failover-resync"),
                                        (str("silent-failover") | str("failover-protocol"))
                                      )
                                  )
                              ),
                              a(str("destruct-timeout"), arg),
                              a(str("tunnel-switch-profile"), arg),
                              b(str("destination"),
                                l2tp_destination_object
                              ),
                              b(str("access-line-information"),
                                l2tp_access_line_object
                              ),
                              b(a(str("session-limit-group"), arg),
                                  c(
                                      a(str("maximum-sessions"), arg)
                                  )
                              ),
                              str("enable-ipv6-services-for-lac"),
                              str("enable-snmp-tunnel-statistics")
                          )
                      ),
                      b(str("adaptive-services-pics"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("routing-socket") | str("routing-protocol") | str("service-identification") | str("configuration") | str("ipc") | str("kernel-object") | str("snmp") | str("all"))).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("license-management"),
                          c(
                              b(str("license-server"),
                                  c(
                                      b(str("ip-address"),
                                        ipv4addr
                                      ),
                                      a(str("log-interval"), arg),
                                      b(str("services"),
                                        (str("jflow") | str("cgnat") | str("firewall"))
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("rtlog"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("source") | str("configuration") | str("all") | str("report") | str("hpl"))).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("soft-gre"),
                          c(
                                soft_gre_tunnel_group_object
                          )
                      ),
                      b(str("hybrid-access"),
                          c(
                                hybrid_access_tunnel_group_object,
                              str("enable-hybrid-access-service"),
                              a(str("dsl-upstream-bandwidth"), arg),
                              a(str("dsl-downstream-bandwidth"), arg),
                              a(str("lte-upstream-bandwidth"), arg),
                              a(str("lte-downstream-bandwidth"), arg),
                              str("disable-key"),
                              str("disable-end-avp"),
                              a(str("max-retransmission-count"), arg),
                              a(str("bypass-bandwidth-check-interval"), arg)
                          )
                      ),
                      b(str("service-interface-pools"),
                          c(
                              b(str("pool"),
                                service_interface_pool_object
                              )
                          )
                      ),
                      b(str("hosted-services"),
                          c(
                              b(a(str("client-profile"), arg),
                                  c(
                                      b(str("transport-type"),
                                        (str("GRE") | str("UDP") | str("TCP"))
                                      ),
                                      b(str("client-address"),
                                        ipv4addr
                                      ),
                                      a(str("hosted-service-identifier"), arg)
                                  )
                              ),
                              b(a(str("server-profile"), arg),
                                  c(
                                      b(str("transport-type"),
                                        (str("GRE") | str("UDP") | str("TCP"))
                                      ),
                                      b(str("server-address"),
                                        ipv4addr
                                      ),
                                      b(str("client-address"),
                                        ipv4addr
                                      ),
                                      a(str("hosted-service-identifier"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("jflow-log"),
                          c(
                              b(a(str("collector"), arg),
                                  c(
                                      a(str("destination-address"), arg),
                                      a(str("destination-port"), arg),
                                      b(str("source-ip"),
                                        ipv4addr
                                      )
                                  )
                              ),
                              b(a(str("collector-group"), arg),
                                  c(
                                      a(str("collector"), arg)
                                  )
                              ),
                              b(a(str("template-profile"), arg),
                                  c(
                                      a(str("collector"), arg),
                                      a(str("collector-group"), arg),
                                      b(str("template-type"),
                                        (str("nat"))
                                      ),
                                      b(str("version"),
                                        (str("v9") | str("ipfix"))
                                      ),
                                      b(str("refresh-rate"),
                                          c(
                                              a(str("packets"), arg),
                                              a(str("seconds"), arg)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("service-device-pools"),
                          c(
                              b(str("pool"),
                                service_device_pool_object
                              )
                          )
                      ),
                      b(str("redundancy-set"),
                          c(
                              b(str("traceoptions"),
                                srd_traceoptions_object
                              ),
                                srd_rs_id_object
                          )
                      ),
                      b(str("traffic-load-balance"),
                        tdir_service_load_balance_object
                      ),
                      b(str("network-monitoring"),
                        tdir_netmon_object
                      ),
                      b(str("web-filter"),
                          c(
                              b(str("profile"),
                                urlf_profile_object
                              ),
                              b(str("traceoptions"),
                                urlf_traceoptions_object
                              )
                          )
                      )
                  )
              ),
              b(str("access-profile"),
                  sc(
                      arg
                  )
              ).as(:oneline),
              # Ported from vSRX 18.3R1.9
              b(str("security"),
                  c(
                      b(str("alarms"),
                          c(
                              b(str("audible"),
                                  c(
                                      str("continuous")
                                  )
                              ),
                              b(str("potential-violation"),
                                  c(
                                      a(str("authentication"), arg),
                                      str("cryptographic-self-test"),
                                      b(str("decryption-failures"),
                                          c(
                                              a(str("threshold"), arg)
                                          )
                                      ),
                                      b(str("encryption-failures"),
                                          c(
                                              a(str("threshold"), arg)
                                          )
                                      ),
                                      b(str("ike-phase1-failures"),
                                          c(
                                              a(str("threshold"), arg)
                                          )
                                      ),
                                      b(str("ike-phase2-failures"),
                                          c(
                                              a(str("threshold"), arg)
                                          )
                                      ),
                                      str("key-generation-self-test"),
                                      str("non-cryptographic-self-test"),
                                      b(str("policy"),
                                          c(
                                              b(str("source-ip"),
                                                  c(
                                                      a(str("threshold"), arg),
                                                      a(str("duration"), arg),
                                                      a(str("size"), arg)
                                                  )
                                              ),
                                              b(str("destination-ip"),
                                                  c(
                                                      a(str("threshold"), arg),
                                                      a(str("duration"), arg),
                                                      a(str("size"), arg)
                                                  )
                                              ),
                                              b(str("application"),
                                                  c(
                                                      a(str("threshold"), arg),
                                                      a(str("duration"), arg),
                                                      a(str("size"), arg)
                                                  )
                                              ),
                                              b(str("policy-match"),
                                                  c(
                                                      a(str("threshold"), arg),
                                                      a(str("duration"), arg),
                                                      a(str("size"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("replay-attacks"),
                                          c(
                                              a(str("threshold"), arg)
                                          )
                                      ),
                                      a(str("security-log-percent-full"), arg),
                                      str("idp")
                                  )
                              )
                          )
                      ),
                      b(str("log"),
                          c(
                              b(a(str("exclude"), arg),
                                  c(
                                      b(str("destination-address"),
                                        ipaddr
                                      ),
                                      a(str("destination-port"), arg),
                                      a(str("event-id"), arg),
                                      str("failure"),
                                      a(str("interface-name"), arg),
                                      a(str("policy-name"), arg),
                                      a(str("process"), arg),
                                      a(str("protocol"), arg),
                                      b(str("source-address"),
                                        ipaddr
                                      ),
                                      a(str("source-port"), arg),
                                      str("success"),
                                      a(str("username"), arg)
                                  )
                              ),
                              a(str("limit"), arg),
                              b(str("cache"),
                                  c(
                                      b(a(str("exclude"), arg),
                                          c(
                                              b(str("destination-address"),
                                                ipaddr
                                              ),
                                              a(str("destination-port"), arg),
                                              a(str("event-id"), arg),
                                              str("failure"),
                                              a(str("interface-name"), arg),
                                              a(str("policy-name"), arg),
                                              a(str("process"), arg),
                                              a(str("protocol"), arg),
                                              b(str("source-address"),
                                                ipaddr
                                              ),
                                              a(str("source-port"), arg),
                                              str("success"),
                                              a(str("username"), arg)
                                          )
                                      ),
                                      a(str("limit"), arg)
                                  )
                              ),
                              str("disable"),
                              str("utc-timestamp"),
                              b(str("mode"),
                                (str("stream") | str("event"))
                              ),
                              a(str("event-rate"), arg),
                              b(str("format"),
                                (str("syslog") | str("sd-syslog") | str("binary"))
                              ),
                              a(str("rate-cap"), arg),
                              a(str("max-database-record"), arg),
                              str("report"),
                              c(
                                b(str("source-address"),
                                  ipaddr
                                ),
                                b(str("source-interface"),
                                  interface_name
                                )
                              ),
                              b(str("transport"),
                                  c(
                                      a(str("tcp-connections"), arg),
                                      b(str("protocol"),
                                        (str("udp") | str("tcp") | str("tls"))
                                      ),
                                      a(str("tls-profile"), arg)
                                  )
                              ),
                              b(str("facility-override"),
                                (str("authorization") | str("daemon") | str("ftp") | str("kernel") | str("user") | str("local0") | str("local1") | str("local2") | str("local3") | str("local4") | str("local5") | str("local6") | str("local7"))
                              ),
                              b(a(str("stream"), arg),
                                  c(
                                      b(str("severity"),
                                        (str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("debug"))
                                      ),
                                      b(str("format"),
                                        (str("syslog") | str("sd-syslog") | str("welf") | str("binary"))
                                      ),
                                      a(str("category"), enum(str("all") | str("content-security") | str("fw-auth") | str("screen") | str("alg") | str("nat") | str("flow") | str("sctp") | str("gtp") | str("ipsec") | str("idp") | str("rtlog") | str("pst-ds-lite") | str("appqos") | str("secintel") | str("aamw"))),
                                      a(str("filter"), enum(str("threat-attack"))),
                                      b(str("host"),
                                        host_object
                                      ),
                                      b(str("rate-limit"),
                                          c(
                                                arg
                                          )
                                      ),
                                      b(str("file"),
                                          c(
                                              a(str("localfilename"), arg),
                                              a(str("size"), arg),
                                              a(str("rotation"), arg),
                                              str("allow-duplicates")
                                          )
                                      )
                                  )
                              ),
                              b(str("file"),
                                  sca(
                                      a(str("size"), arg),
                                      a(str("path"), arg),
                                      a(str("files"), arg)
                                  )
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("source") | str("configuration") | str("all") | str("report") | str("hpl"))).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("certificates"),
                          c(
                              b(str("local"),
                                certificate_object
                              ),
                              a(str("path-length"), arg),
                              a(str("maximum-certificates"), arg),
                              a(str("cache-size"), arg),
                              a(str("cache-timeout-negative"), arg),
                              a(str("enrollment-retry"), arg),
                              b(a(str("certification-authority"), arg),
                                  c(
                                      a(str("ca-name"), arg),
                                      a(str("file"), arg),
                                      a(str("crl"), arg),
                                      a(str("enrollment-url"), arg),
                                      a(str("ldap-url"), arg),
                                      b(str("encoding"),
                                        (str("binary") | str("pem"))
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("authentication-key-chains"),
                        security_authentication_key_chains
                      ),
                      b(str("ssh-known-hosts"),
                          c(
                              b(a(str("host"), arg),
                                  c(
                                      a(str("rsa1-key"), arg),
                                      a(str("rsa-key"), arg),
                                      a(str("dsa-key"), arg),
                                      a(str("ecdsa-key"), arg),
                                      a(str("ecdsa-sha2-nistp256-key"), arg),
                                      a(str("ecdsa-sha2-nistp384-key"), arg),
                                      a(str("ecdsa-sha2-nistp521-key"), arg),
                                      a(str("ed25519-key"), arg)
                                  )
                              )
                          )
                      ),
                      str("key-protection"),
                      b(str("pki"),
                        security_pki
                      ),
                      b(str("ike"),
                        security_ike
                      ),
                      b(str("ipsec"),
                        security_ipsec_vpn
                      ),
                      b(str("group-vpn"),
                        security_group_vpn
                      ),
                      b(str("ipsec-policy"),
                        security_ipsec_policies
                      ),
                      b(str("idp"),
                          c(
                              b(str("idp-policy"),
                                idp_policy_type
                              ),
                              a(str("active-policy"), arg),
                              a(str("default-policy"), arg),
                              b(str("custom-attack"),
                                custom_attack_type
                              ),
                              b(str("custom-attack-group"),
                                custom_attack_group_type
                              ),
                              b(str("dynamic-attack-group"),
                                dynamic_attack_group_type
                              ),
                              b(str("traceoptions"),
                                idpd_traceoptions_type
                              ),
                              b(str("security-package"),
                                  c(
                                      a(str("url"), arg),
                                      b(str("source-address"),
                                        ipv4addr
                                      ),
                                      a(str("proxy-profile"), arg),
                                      b(str("install"),
                                          c(
                                              str("ignore-version-check")
                                          )
                                      ),
                                      b(str("automatic"),
                                          c(
                                              b(str("start-time"),
                                                time
                                              ),
                                              a(str("interval"), arg),
                                              a(str("download-timeout"), arg),
                                                (str("enable"))
                                          )
                                      )
                                  )
                              ),
                              b(str("sensor-configuration"),
                                  c(
                                      b(str("log"),
                                          c(
                                              a(str("cache-size"), arg),
                                              b(str("suppression"),
                                                  c(
                                                        (str("disable")),
                                                      str("include-destination-address"),
                                                      str("no-include-destination-address"),
                                                      a(str("start-log"), arg),
                                                      a(str("max-logs-operate"), arg),
                                                      a(str("max-time-report"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("packet-log"),
                                          c(
                                              a(str("total-memory"), arg),
                                              a(str("max-sessions"), arg),
                                              a(str("threshold-logging-interval"), arg),
                                              b(str("source-address"),
                                                ipv4addr
                                              ),
                                              b(str("host"),
                                                  c(
                                                        ipv4addr,
                                                      a(str("port"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("application-identification"),
                                          c(
                                                (str("disable")),
                                              str("application-system-cache"),
                                              str("no-application-system-cache"),
                                              a(str("max-tcp-session-packet-memory"), arg),
                                              a(str("max-udp-session-packet-memory"), arg),
                                              a(str("max-sessions"), arg),
                                              a(str("max-packet-memory"), arg),
                                              a(str("max-packet-memory-ratio"), arg),
                                              a(str("max-reass-packet-memory-ratio"), arg),
                                              a(str("application-system-cache-timeout"), arg)
                                          )
                                      ),
                                      b(str("flow"),
                                          c(
                                              str("log-errors"),
                                              str("no-log-errors"),
                                              str("reset-on-policy"),
                                              str("no-reset-on-policy"),
                                              str("allow-icmp-without-flow"),
                                              str("no-allow-icmp-without-flow"),
                                              a(str("hash-table-size"), arg),
                                              a(str("reject-timeout"), arg),
                                              a(str("max-timers-poll-ticks"), arg),
                                              a(str("fifo-max-size"), arg),
                                              a(str("udp-anticipated-timeout"), arg),
                                              str("allow-nonsyn-connection"),
                                              str("drop-on-limit"),
                                              str("drop-on-failover"),
                                              str("drop-if-no-policy-loaded"),
                                              a(str("max-sessions-offset"), arg),
                                              a(str("min-objcache-limit-lt"), arg),
                                              a(str("min-objcache-limit-ut"), arg),
                                              str("session-steering"),
                                              str("idp-bypass-cpu-usg-overload"),
                                              a(str("idp-bypass-cpu-threshold"), arg),
                                              a(str("idp-bypass-cpu-tolerance"), arg)
                                          )
                                      ),
                                      b(str("re-assembler"),
                                          c(
                                              str("drop-on-syn-in-window"),
                                              str("no-drop-on-syn-in-window"),
                                              str("ignore-memory-overflow"),
                                              str("no-ignore-memory-overflow"),
                                              str("ignore-reassembly-memory-overflow"),
                                              str("no-ignore-reassembly-memory-overflow"),
                                              str("ignore-reassembly-overflow"),
                                              a(str("max-packet-mem"), arg),
                                              a(str("max-flow-mem"), arg),
                                              a(str("max-packet-mem-ratio"), arg),
                                              b(str("action-on-reassembly-failure"),
                                                (str("ignore") | str("drop") | str("drop-session"))
                                              ),
                                              str("tcp-error-logging"),
                                              str("no-tcp-error-logging"),
                                              a(str("max-synacks-queued"), arg),
                                              str("force-tcp-window-checks"),
                                              str("no-force-tcp-window-checks")
                                          )
                                      ),
                                      b(str("ips"),
                                          c(
                                              str("process-override"),
                                              str("no-process-override"),
                                              str("detect-shellcode"),
                                              str("no-detect-shellcode"),
                                              str("process-ignore-s2c"),
                                              str("no-process-ignore-s2c"),
                                              str("ignore-regular-expression"),
                                              str("no-ignore-regular-expression"),
                                              a(str("process-port"), arg),
                                              a(str("fifo-max-size"), arg),
                                              a(str("log-supercede-min"), arg),
                                              a(str("content-decompression-max-memory-kb"), arg),
                                              a(str("content-decompression-max-ratio"), arg),
                                              a(str("session-pkt-depth"), arg)
                                          )
                                      ),
                                      b(str("global"),
                                          c(
                                              str("enable-packet-pool"),
                                              str("no-enable-packet-pool"),
                                              str("enable-all-qmodules"),
                                              str("no-enable-all-qmodules"),
                                              str("policy-lookup-cache"),
                                              str("no-policy-lookup-cache"),
                                              a(str("memory-limit-percent"), arg)
                                          )
                                      ),
                                      b(str("detector"),
                                          c(
                                              b(str("protocol-name"),
                                                proto_object
                                              )
                                          )
                                      ),
                                      b(str("ssl-inspection"),
                                          c(
                                              a(str("sessions"), arg),
                                              a(str("session-id-cache-timeout"), arg),
                                              a(str("maximum-cache-size"), arg),
                                              a(str("cache-prune-chunk-size"), arg),
                                              str("key-protection")
                                          )
                                      ),
                                      str("disable-low-memory-handling"),
                                      b(str("high-availability"),
                                          c(
                                              str("no-policy-cold-synchronization")
                                          )
                                      ),
                                      b(str("security-configuration"),
                                          c(
                                              b(str("protection-mode"),
                                                (str("datacenter") | str("datacenter-full") | str("perimeter") | str("perimeter-full"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              a(str("max-sessions"), arg),
                              b(str("logical-system"),
                                logical_system_type
                              ),
                              str("processes")
                          )
                      ),
                      b(str("address-book"),
                        named_address_book_type
                      ),
                      b(str("alg"),
                        alg_object
                      ),
                      b(str("application-firewall"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("configuration") | str("lookup") | str("compilation") | str("ipc") | str("all"))).as(:oneline)
                                  )
                              ),
                              b(a(str("profile"), arg),
                                  c(
                                      b(str("block-message"),
                                          c(
                                              b(str("type"),
                                                  c(
                                                      c(
                                                        b(str("custom-text"),
                                                            c(
                                                                a(str("content"), arg)
                                                            )
                                                        ),
                                                        b(str("custom-redirect-url"),
                                                            c(
                                                                a(str("content"), arg)
                                                            )
                                                        )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("rule-sets"), arg),
                                  c(
                                      b(str("rule"),
                                        appfw_rule_type
                                      ),
                                      b(str("default-rule"),
                                          c(
                                              c(
                                                str("permit"),
                                                b(str("deny"),
                                                    c(
                                                        str("block-message")
                                                    )
                                                ),
                                                b(str("reject"),
                                                    c(
                                                        str("block-message")
                                                    )
                                                )
                                              )
                                          )
                                      ),
                                      a(str("profile"), arg)
                                  )
                              ),
                              b(str("nested-application"),
                                  c(
                                      b(str("dynamic-lookup"),
                                          c(
                                              str("enable")
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("application-tracking"),
                          c(
                              str("disable"),
                              c(
                                a(str("first-update-interval"), arg),
                                str("first-update")
                              ),
                              a(str("session-update-interval"), arg)
                          )
                      ),
                      b(str("utm"),
                          c(
                              b(str("traceoptions"),
                                utm_traceoptions
                              ),
                              b(str("application-proxy"),
                                  c(
                                      b(str("traceoptions"),
                                        utm_apppxy_traceoptions
                                      )
                                  )
                              ),
                              b(str("ipc"),
                                  c(
                                      b(str("traceoptions"),
                                        utm_ipc_traceoptions
                                      )
                                  )
                              ),
                              b(str("custom-objects"),
                                  c(
                                      b(str("category-package"),
                                          c(
                                              a(str("url"), arg),
                                              a(str("proxy-profile"), arg),
                                              a(str("routing-instance"), arg),
                                              b(str("automatic"),
                                                  c(
                                                      b(str("start-time"),
                                                        time
                                                      ),
                                                      a(str("interval"), arg),
                                                      str("enable")
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("mime-pattern"),
                                        mime_list_type
                                      ),
                                      b(str("filename-extension"),
                                        extension_list_type
                                      ),
                                      b(str("url-pattern"),
                                        url_list_type
                                      ),
                                      b(str("custom-url-category"),
                                        category_list_type
                                      ),
                                      b(str("protocol-command"),
                                        command_list_type
                                      ),
                                      b(str("custom-message"),
                                        custom_message_type
                                      )
                                  )
                              ),
                              b(str("default-configuration"),
                                  c(
                                      b(str("anti-virus"),
                                        default_anti_virus_feature
                                      ),
                                      b(str("web-filtering"),
                                        default_webfilter_feature
                                      ),
                                      b(str("anti-spam"),
                                        default_anti_spam_feature
                                      ),
                                      b(str("content-filtering"),
                                        default_content_filtering_feature
                                      )
                                  )
                              ),
                              b(str("feature-profile"),
                                  c(
                                      b(str("anti-virus"),
                                        anti_virus_feature
                                      ),
                                      b(str("web-filtering"),
                                        webfilter_feature
                                      ),
                                      b(str("anti-spam"),
                                        anti_spam_feature
                                      ),
                                      b(str("content-filtering"),
                                        content_filtering_feature
                                      )
                                  )
                              ),
                              b(str("utm-policy"),
                                profile_setting
                              )
                          )
                      ),
                      b(str("dynamic-address"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      b(str("level"),
                                        (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                      ),
                                      a(str("flag"), enum(str("configuration") | str("control") | str("ipc") | str("ip-entry") | str("file-retrieval") | str("lookup") | str("all"))).as(:oneline)
                                  )
                              ),
                              b(a(str("feed-server"), arg),
                                  c(
                                      a(str("description"), quote | arg),
                                      a(str("hostname"), arg),
                                      a(str("update-interval"), arg),
                                      a(str("hold-interval"), arg),
                                      b(a(str("feed-name"), arg),
                                          c(
                                              a(str("description"), quote | arg),
                                              a(str("path"), arg),
                                              a(str("update-interval"), arg),
                                              a(str("hold-interval"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(a(str("address-name"), arg),
                                  c(
                                      a(str("description"), quote | arg),
                                      b(str("profile"),
                                          c(
                                              a(str("feed-name"), arg),
                                              b(a(str("category"), arg),
                                                  c(
                                                      a(str("feed"), arg),
                                                      b(a(str("property"), arg),
                                                          c(
                                                              c(
                                                                a(str("string"), arg)
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      str("dynamic-vpn"),
                      b(str("dynamic-application"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("configuration") | str("lookup") | str("compilation") | str("ipc") | str("all"))).as(:oneline)
                                  )
                              ),
                              b(a(str("profile"), arg),
                                  c(
                                      b(str("redirect-message"),
                                          c(
                                              b(str("type"),
                                                  c(
                                                      c(
                                                        b(str("custom-text"),
                                                            c(
                                                                a(str("content"), arg)
                                                            )
                                                        ),
                                                        b(str("redirect-url"),
                                                            c(
                                                                a(str("content"), arg)
                                                            )
                                                        )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("softwires"),
                        softwires_object
                      ),
                      b(str("forwarding-options"),
                          c(
                              b(str("family"),
                                  c(
                                      b(str("inet6"),
                                          c(
                                              b(str("mode"),
                                                (str("packet-based") | str("flow-based") | str("drop"))
                                              )
                                          )
                                      ),
                                      b(str("mpls"),
                                          c(
                                              b(str("mode"),
                                                (str("packet-based"))
                                              )
                                          )
                                      ),
                                      b(str("iso"),
                                          c(
                                              b(str("mode"),
                                                (str("packet-based"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("mirror-filter"),
                                mirror_filter_type
                              ),
                              b(str("secure-wire"),
                                secure_wire_type
                              )
                          )
                      ),
                      str("advanced-services"),
                      b(str("flow"),
                          c(
                              str("enhanced-routing-mode"),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("all") | str("basic-datapath") | str("high-availability") | str("host-traffic") | str("fragmentation") | str("multicast") | str("route") | str("session") | str("session-scan") | str("tcp-basic") | str("tunnel"))).as(:oneline),
                                      a(str("rate-limit"), arg),
                                      b(str("packet-filter"),
                                        flow_filter_type
                                      ),
                                      b(str("trace-level"),
                                          c(
                                              c(
                                                str("error"),
                                                str("brief"),
                                                str("detail")
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("pending-sess-queue-length"),
                                (str("normal") | str("moderate") | str("high"))
                              ),
                              b(str("enable-reroute-uniform-link-check"),
                                  c(
                                      str("nat")
                                  )
                              ),
                              str("allow-dns-reply"),
                              a(str("route-change-timeout"), arg),
                              b(str("syn-flood-protection-mode"),
                                (str("syn-cookie") | str("syn-proxy"))
                              ),
                              str("allow-embedded-icmp"),
                              str("mcast-buffer-enhance"),
                              str("allow-reverse-ecmp"),
                              str("sync-icmp-session"),
                              str("ipsec-performance-acceleration"),
                              b(str("aging"),
                                  c(
                                      a(str("early-ageout"), arg),
                                      a(str("low-watermark"), arg),
                                      a(str("high-watermark"), arg)
                                  )
                              ),
                              b(str("ethernet-switching"),
                                  c(
                                      str("block-non-ip-all"),
                                      str("bypass-non-ip-unicast"),
                                      b(str("no-packet-flooding"),
                                          c(
                                              str("no-trace-route")
                                          )
                                      ),
                                      str("bpdu-vlan-flooding")
                                  )
                              ),
                              b(str("tcp-mss"),
                                  c(
                                      b(str("all-tcp"),
                                          c(
                                              a(str("mss"), arg)
                                          )
                                      ),
                                      b(str("ipsec-vpn"),
                                          c(
                                              a(str("mss"), arg)
                                          )
                                      ),
                                      b(str("gre-in"),
                                          c(
                                              a(str("mss"), arg)
                                          )
                                      ),
                                      b(str("gre-out"),
                                          c(
                                              a(str("mss"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("tcp-session"),
                                  c(
                                      str("rst-invalidate-session"),
                                      str("fin-invalidate-session"),
                                      str("rst-sequence-check"),
                                      str("no-syn-check"),
                                      str("strict-syn-check"),
                                      str("no-syn-check-in-tunnel"),
                                      str("no-sequence-check"),
                                      a(str("tcp-initial-timeout"), arg),
                                      b(str("maximum-window"),
                                        (str("64K") | str("128K") | str("256K") | str("512K") | str("1M"))
                                      ),
                                      b(str("time-wait-state"),
                                          c(
                                              c(
                                                str("session-ageout"),
                                                a(str("session-timeout"), arg)
                                              ),
                                              str("apply-to-half-close-state")
                                          )
                                      )
                                  )
                              ),
                              str("force-ip-reassembly"),
                              str("preserve-incoming-fragment-size"),
                              b(str("advanced-options"),
                                  c(
                                      str("drop-matching-reserved-ip-address"),
                                      str("drop-matching-link-local-address"),
                                      str("reverse-route-packet-mode-vr")
                                  )
                              ),
                              b(str("load-distribution"),
                                  c(
                                      str("session-affinity")
                                  )
                              ),
                              b(str("packet-log"),
                                  c(
                                      str("enable"),
                                      a(str("throttle-interval"), arg),
                                      b(str("packet-filter"),
                                        flow_filter_type
                                      )
                                  )
                              ),
                              str("power-mode-ipsec")
                          )
                      ),
                      b(str("firewall-authentication"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      a(str("flag"), enum(str("authentication") | str("proxy") | str("all")),
                                          sc(
                                              c(
                                                str("terse"),
                                                str("detail"),
                                                str("extensive")
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("screen"),
                          c(
                              b(str("trap"),
                                  sc(
                                      a(str("interval"), arg)
                                  )
                              ).as(:oneline),
                              b(str("ids-option"),
                                ids_option_type
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("configuration") | str("flow") | str("all"))).as(:oneline)
                                  )
                              ),
                              b(str("white-list"),
                                ids_wlist_type
                              )
                          )
                      ),
                      b(str("nat"),
                        nat_object
                      ),
                      b(str("forwarding-process"),
                          c(
                              str("enhanced-services-mode"),
                              b(str("application-services"),
                                  c(
                                      str("maximize-alg-sessions"),
                                      str("maximize-persistent-nat-capacity"),
                                      str("maximize-cp-sessions"),
                                      a(str("session-distribution-mode"), arg),
                                      str("enable-gtpu-distribution"),
                                      a(str("packet-ordering-mode"), arg),
                                      str("maximize-idp-sessions")
                                  )
                              )
                          )
                      ),
                      b(str("policies"),
                        policy_object_type
                      ),
                      b(str("tcp-encap"),
                          c(
                              b(str("traceoptions"),
                                ragw_traceoptions
                              ),
                              b(a(str("profile"), arg),
                                  c(
                                      a(str("ssl-profile"), arg),
                                      str("log")
                                  )
                              ),
                              b(str("global-options"),
                                  c(
                                      str("enable-tunnel-tracking")
                                  )
                              )
                          )
                      ),
                      b(str("resource-manager"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      a(str("flag"), enum(str("client") | str("group") | str("resource") | str("gate") | str("session") | str("chassis cluster") | str("messaging") | str("service pinhole") | str("error") | str("all")),
                                          sc(
                                              c(
                                                str("terse"),
                                                str("detail"),
                                                str("extensive")
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("analysis"),
                          c(
                              str("no-report")
                          )
                      ),
                      b(str("traceoptions"),
                          c(
                              str("no-remote-trace"),
                              b(str("file"),
                                  sc(
                                        arg,
                                      a(str("size"), arg),
                                      a(str("files"), arg),
                                      str("world-readable"),
                                      str("no-world-readable"),
                                      b(str("match"),
                                        regular_expression
                                      )
                                  )
                              ).as(:oneline),
                              a(str("flag"), enum(str("configuration") | str("routing-socket") | str("compilation") | str("all"))).as(:oneline),
                              a(str("rate-limit"), arg)
                          )
                      ),
                      b(str("datapath-debug"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(str("capture-file"),
                                  sc(
                                      arg,
                                      b(str("format"),
                                        (str("pcap"))
                                      ),
                                      a(str("size"), arg),
                                      a(str("files"), arg),
                                      str("world-readable"),
                                      str("no-world-readable")
                                  )
                              ).as(:oneline),
                              a(str("maximum-capture-size"), arg),
                              b(str("action-profile"),
                                e2e_action_profile
                              ),
                              b(str("packet-filter"),
                                end_to_end_debug_filter
                              )
                          )
                      ),
                      b(str("user-identification"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("all"))).as(:oneline)
                                  )
                              ),
                              b(str("authentication-source"),
                                authentication_source_type
                              )
                          )
                      ),
                      b(str("zones"),
                          c(
                              b(str("functional-zone"),
                                  c(
                                      b(str("management"),
                                          c(
                                              b(str("interfaces"),
                                                zone_interface_list_type
                                              ),
                                              a(str("screen"), arg),
                                              b(str("host-inbound-traffic"),
                                                zone_host_inbound_traffic_t
                                              ),
                                              a(str("description"), quote | arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("security-zone"),
                                security_zone_type
                              )
                          )
                      ),
                      b(str("advance-policy-based-routing"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("configuration") | str("lookup") | str("compilation") | str("ipc") | str("all"))).as(:oneline)
                                  )
                              ),
                              b(str("tunables"),
                                  c(
                                      a(str("max-route-change"), arg),
                                      str("drop-on-zone-mismatch"),
                                      str("enable-logging")
                                  )
                              ),
                              b(a(str("profile"), arg),
                                  c(
                                      b(str("rule"),
                                        apbr_rule_type
                                      )
                                  )
                              ),
                              b(a(str("active-probe-params"), arg),
                                  c(
                                      b(str("settings"),
                                        appqoe_probe_params
                                      )
                                  )
                              ),
                              b(a(str("metrics-profile"), arg),
                                  c(
                                      b(str("sla-threshold"),
                                        appqoe_sla_metric_profile
                                      )
                                  )
                              ),
                              b(a(str("overlay-path"), arg),
                                  c(
                                      b(str("tunnel-path"),
                                        appqoe_probe_path
                                      ),
                                      b(str("probe-path"),
                                        appqoe_probe_path
                                      )
                                  )
                              ),
                              b(a(str("destination-path-group"), arg),
                                  c(
                                      b(str("probe-routing-instance"),
                                          c(
                                              arg
                                          )
                                      ),
                                      a(str("overlay-path"), arg)
                                  )
                              ),
                              b(str("sla-options"),
                                  c(
                                      b(str("local-route-switch"),
                                          c(
                                              c(
                                                str("enabled"),
                                                str("disabled")
                                              )
                                          )
                                      ),
                                      b(str("log-type"),
                                          c(
                                              c(
                                                str("syslog")
                                              )
                                          )
                                      ),
                                      b(str("max-passive-probe-limit"),
                                          c(
                                              b(str("number-of-probes"),
                                                  c(
                                                        arg
                                                  )
                                              ),
                                              b(str("interval"),
                                                  c(
                                                        arg
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("sla-rule"), arg),
                                  c(
                                      b(str("switch-idle-time"),
                                          c(
                                                arg
                                          )
                                      ),
                                      b(str("metrics-profile"),
                                          c(
                                              arg
                                          )
                                      ),
                                      b(str("active-probe-params"),
                                          c(
                                              arg
                                          )
                                      ),
                                      b(str("passive-probe-params"),
                                          c(
                                              b(str("sampling-percentage"),
                                                  c(
                                                        arg
                                                  )
                                              ),
                                              b(str("violation-count"),
                                                  c(
                                                        arg
                                                  )
                                              ),
                                              b(str("sampling-period"),
                                                  c(
                                                        arg
                                                  )
                                              ),
                                              b(str("sla-export-factor"),
                                                  c(
                                                        arg
                                                  )
                                              ),
                                              b(str("type"),
                                                  c(
                                                      c(
                                                        str("book-ended")
                                                      )
                                                  )
                                              ),
                                              b(str("sampling-frequency"),
                                                  c(
                                                      b(str("interval"),
                                                          c(
                                                                arg
                                                          )
                                                      ),
                                                      b(str("ratio"),
                                                          c(
                                                                arg
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("policy"), arg),
                                  c(
                                      b(str("policy"),
                                        sla_policy_type
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("gprs"),
                          c(
                              b(str("gtp"),
                                  c(
                                      b(a(str("profile"), arg),
                                          c(
                                              a(str("min-message-length"), arg),
                                              a(str("max-message-length"), arg),
                                              a(str("timeout"), arg),
                                              a(str("rate-limit"), arg),
                                              b(str("log"),
                                                  c(
                                                      b(str("forwarded"),
                                                        (str("basic") | str("detail"))
                                                      ),
                                                      b(str("state-invalid"),
                                                        (str("basic") | str("detail"))
                                                      ),
                                                      b(str("prohibited"),
                                                        (str("basic") | str("detail"))
                                                      ),
                                                      a(str("gtp-u"), enum(str("all") | str("dropped"))),
                                                      b(str("rate-limited"),
                                                          c(
                                                              c(
                                                                str("basic"),
                                                                str("detail")
                                                              ),
                                                              a(str("frequency-number"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("remove-ie"),
                                                  c(
                                                      a(str("version"), enum(str("v1")),
                                                          c(
                                                              a(str("release"), enum(str("R6") | str("R7") | str("R8") | str("R9"))),
                                                              b(str("number"),
                                                                  c(
                                                                        arg
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("path-rate-limit"),
                                                  c(
                                                      a(str("message-type"), enum(str("create-req") | str("delete-req") | str("echo-req") | str("other")),
                                                          c(
                                                              b(str("drop-threshold"),
                                                                  c(
                                                                      a(str("forward"), arg),
                                                                      a(str("reverse"), arg)
                                                                  )
                                                              ),
                                                              b(str("alarm-threshold"),
                                                                  c(
                                                                      a(str("forward"), arg),
                                                                      a(str("reverse"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("drop"),
                                                  c(
                                                      b(str("aa-create-pdp"),
                                                          c(
                                                              c(
                                                                str("0")
                                                              )
                                                          )
                                                      ),
                                                      b(str("aa-delete-pdp"),
                                                          c(
                                                              c(
                                                                str("0")
                                                              )
                                                          )
                                                      ),
                                                      b(str("bearer-resource"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("change-notification"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("config-transfer"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("context"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("create-bearer"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("create-data-forwarding"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("create-pdp"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("create-session"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("create-tnl-forwarding"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("cs-paging"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("data-record"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("delete-bearer"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("delete-command"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("delete-data-forwarding"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("delete-pdn"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("delete-pdp"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("delete-session"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("detach"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("downlink-notification"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("echo"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("error-indication"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("failure-report"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("fwd-access"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("fwd-relocation"),
                                                          c(
                                                              c(
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("fwd-srns-context"),
                                                          c(
                                                              c(
                                                                str("1")
                                                              )
                                                          )
                                                      ),
                                                      b(str("g-pdu"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("identification"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("mbms-session-start"),
                                                          c(
                                                              c(
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("mbms-session-stop"),
                                                          c(
                                                              c(
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("mbms-session-update"),
                                                          c(
                                                              c(
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("modify-bearer"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("modify-command"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("node-alive"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("note-ms-present"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("pdu-notification"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("ran-info"),
                                                          c(
                                                              c(
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("redirection"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("release-access"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("relocation-cancel"),
                                                          c(
                                                              c(
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("resume"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("send-route"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("sgsn-context"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("stop-paging"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("supported-extension"),
                                                          c(
                                                              c(
                                                                str("1")
                                                              )
                                                          )
                                                      ),
                                                      b(str("suspend"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("trace-session"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("update-bearer"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("update-pdn"),
                                                          c(
                                                              c(
                                                                str("2")
                                                              )
                                                          )
                                                      ),
                                                      b(str("update-pdp"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("all")
                                                              )
                                                          )
                                                      ),
                                                      b(str("ver-not-supported"),
                                                          c(
                                                              c(
                                                                str("0"),
                                                                str("1"),
                                                                str("2"),
                                                                str("all")
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(a(str("apn"), arg),
                                                  c(
                                                      b(a(str("imsi-prefix"), arg),
                                                          c(
                                                              b(str("action"),
                                                                  c(
                                                                      c(
                                                                        str("pass"),
                                                                        str("drop"),
                                                                        b(str("selection"),
                                                                            c(
                                                                                str("ms"),
                                                                                str("net"),
                                                                                str("vrf")
                                                                            )
                                                                        )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("restart-path"),
                                                (str("echo") | str("create") | str("all"))
                                              ),
                                              str("seq-number-validated"),
                                              str("gtp-in-gtp-denied"),
                                              str("u-tunnel-validated"),
                                              str("end-user-address-validated"),
                                              a(str("req-timeout"), arg),
                                              str("handover-on-roaming-intf"),
                                              b(str("handover-group"),
                                                  c(
                                                        arg
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("traceoptions"),
                                          c(
                                              str("no-remote-trace"),
                                              b(str("file"),
                                                  sc(
                                                        arg,
                                                      a(str("size"), arg),
                                                      a(str("files"), arg),
                                                      str("world-readable"),
                                                      str("no-world-readable"),
                                                      b(str("match"),
                                                        regular_expression
                                                      )
                                                  )
                                              ).as(:oneline),
                                              a(str("flag"), enum(str("configuration") | str("flow") | str("parser") | str("chassis-cluster") | str("gsn") | str("jmpi") | str("tnl") | str("req") | str("path") | str("all"))).as(:oneline),
                                              b(str("trace-level"),
                                                  c(
                                                      c(
                                                        str("error"),
                                                        str("warning"),
                                                        str("notice"),
                                                        str("info"),
                                                        str("verbose")
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(a(str("handover-group"), arg),
                                          c(
                                              b(a(str("address-book"), arg),
                                                  c(
                                                      b(str("address-set"),
                                                          c(
                                                                arg
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("handover-default"),
                                          c(
                                              str("deny")
                                          )
                                      )
                                  )
                              ),
                              b(str("sctp"),
                                  c(
                                      b(a(str("profile"), arg),
                                          c(
                                              str("nat-only"),
                                              a(str("association-timeout"), arg),
                                              a(str("handshake-timeout"), arg),
                                              b(str("drop"),
                                                  c(
                                                      a(str("m3ua-service"), enum(str("sccp") | str("tup") | str("isup"))).as(:oneline),
                                                      a(str("payload-protocol"), enum(str("reserved") | str("iua") | str("m2ua") | str("m3ua") | str("sua") | str("m2pa") | str("v5ua") | str("h248") | str("bicc") | str("tali") | str("dua") | str("asap") | str("enrp") | str("h323") | str("qipc") | str("simco") | str("ddp-segment") | str("ddp-stream") | str("s1ap") | str("x2ap") | str("diameter-sctp") | str("diameter-dtls") | str("all") | arg)).as(:oneline)
                                                  )
                                              ),
                                              b(str("permit"),
                                                  c(
                                                      a(str("payload-protocol"), enum(str("reserved") | str("iua") | str("m2ua") | str("m3ua") | str("sua") | str("m2pa") | str("v5ua") | str("h248") | str("bicc") | str("tali") | str("dua") | str("asap") | str("enrp") | str("h323") | str("qipc") | str("simco") | str("ddp-segment") | str("ddp-stream") | str("s1ap") | str("x2ap") | str("diameter-sctp") | str("diameter-dtls") | str("all") | arg)).as(:oneline)
                                                  )
                                              ),
                                              b(str("limit"),
                                                  c(
                                                      a(str("payload-protocol"), enum(str("reserved") | str("iua") | str("m2ua") | str("m3ua") | str("sua") | str("m2pa") | str("v5ua") | str("h248") | str("bicc") | str("tali") | str("dua") | str("asap") | str("enrp") | str("h323") | str("qipc") | str("simco") | str("ddp-segment") | str("ddp-stream") | str("s1ap") | str("x2ap") | str("diameter-sctp") | str("diameter-dtls") | str("others") | arg),
                                                          sc(
                                                              a(str("rate"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(a(str("address"), arg),
                                                          c(
                                                              a(str("payload-protocol"), enum(str("reserved") | str("iua") | str("m2ua") | str("m3ua") | str("sua") | str("m2pa") | str("v5ua") | str("h248") | str("bicc") | str("tali") | str("dua") | str("asap") | str("enrp") | str("h323") | str("qipc") | str("simco") | str("ddp-segment") | str("ddp-stream") | str("s1ap") | str("x2ap") | str("diameter-sctp") | str("diameter-dtls") | str("others") | arg),
                                                                  sc(
                                                                      a(str("rate"), arg)
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ),
                                                      b(str("rate"),
                                                          c(
                                                              a(str("sccp"), arg),
                                                              a(str("ssp"), arg),
                                                              a(str("sst"), arg),
                                                              b(a(str("address"), arg),
                                                                  c(
                                                                      a(str("sccp"), arg),
                                                                      a(str("ssp"), arg),
                                                                      a(str("sst"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("multichunk-inspection"),
                                          c(
                                              c(
                                                str("disable")
                                              )
                                          )
                                      ),
                                      b(str("nullpdu"),
                                          c(
                                              b(str("protocol"),
                                                  c(
                                                      c(
                                                        str("ID-0x0000"),
                                                        str("ID-0xFFFF")
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      a(str("log"), enum(str("configuration") | str("rate-limit") | str("association") | str("data-message-drop") | str("control-message-drop") | str("control-message-all"))).as(:oneline),
                                      b(str("traceoptions"),
                                          c(
                                              str("no-remote-trace"),
                                              b(str("file"),
                                                  sc(
                                                        arg,
                                                      a(str("size"), arg),
                                                      a(str("files"), arg),
                                                      str("world-readable"),
                                                      str("no-world-readable"),
                                                      b(str("match"),
                                                        regular_expression
                                                      )
                                                  )
                                              ).as(:oneline),
                                              a(str("flag"), enum(str("configuration") | str("detail") | str("flow") | str("parser") | str("chassis-cluster") | str("all"))).as(:oneline)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("ngfw"),
                          c(
                              b(str("default-profile"),
                                  c(
                                      b(str("ssl-proxy"),
                                          c(
                                              a(str("profile-name"), arg)
                                          )
                                      ),
                                      b(str("application-traffic-control"),
                                        jsf_application_traffic_control_rule_set_type
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("macsec"),
                        security_macsec
                      )
                  )
              ),
              # End of vSRX 18.3R1.9
              b(str("interfaces"),
                  c(
                      b(a(str("pic-set"), arg),
                          c(
                              a(str("interface"), arg),
                              b(a(str("fpc"), arg),
                                  c(
                                      a(str("pic"), arg)
                                  )
                              )
                          )
                      ),
                      a(str("interface-set"), arg | arg | arg | arg | arg | arg,
                          c(
                              str("targeted-distribution"),
                              b(str("targeted-options"),
                                  c(
                                      b(str("weight"),
                                        (arg | arg)
                                      )
                                  )
                              ),
                              b(a(str("interface"), arg),
                                  c(
                                      a(str("unit"), arg),
                                      a(str("vlan-tags-outer"), arg)
                                  )
                              ),
                              b(str("pppoe-underlying-options"),
                                pppoe_underlying_options_type
                              )
                          )
                      ),
                      b(str("stacked-interface-set"),
                          c(
                              a(str("interface-set"), arg | arg,
                                  c(
                                      a(str("interface-set"), arg | arg | arg | arg | arg | arg)
                                  )
                              )
                          )
                      ),
                      b(str("traceoptions"),
                          c(
                              str("no-remote-trace"),
                              b(str("file"),
                                  sc(
                                        arg,
                                      a(str("size"), arg),
                                      a(str("files"), arg),
                                      str("world-readable"),
                                      str("no-world-readable"),
                                      b(str("match"),
                                        regular_expression
                                      )
                                  )
                              ).as(:oneline),
                              a(str("flag"), enum(str("all") | str("kernel") | str("change-events") | str("kernel-detail") | str("config-states") | str("resource-usage") | str("gres-events") | str("select-events") | str("bfd-events") | str("lib-events") | str("reserved") | str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("informational") | str("debugging") | str("verbose") | str("japi")),
                                  sc(
                                      str("disable")
                                  )
                              ).as(:oneline)
                          )
                      ),
                      b(a(str("interface-range"), arg),
                          c(
                              a(str("member"), arg),
                              b(a(str("member-range"), arg),
                                  sc(
                                      b(str("end-range"),
                                        interface_device
                                      )
                                  )
                              ).as(:oneline),
                              a(str("description"), quote | arg),
                              a(str("external-model-name"), arg),
                              a(str("metadata"), arg),
                                (str("disable")),
                              str("promiscuous-mode"),
                              a(str("port-mirror-instance"), arg),
                              str("multicast-statistics"),
                              str("oam-on-svlan"),
                              b(str("fabric-options"),
                                  c(
                                      a(str("member-interfaces"), arg),
                                      b(str("remote-chassis"),
                                          c(
                                              b(str("destination"),
                                                ipv4addr
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("traceoptions"),
                                  c(
                                      a(str("flag"), enum(str("ipc") | str("event") | str("media") | str("all"))).as(:oneline)
                                  )
                              ),
                              str("passive-monitor-mode"),
                              c(
                                b(str("keepalives"),
                                  keepalives_type
                                ).as(:oneline),
                                str("no-keepalives")
                              ),
                              str("traps"),
                              str("no-traps"),
                              str("interface-mib"),
                              str("no-interface-mib"),
                              a(str("accounting-profile"), arg),
                              b(str("anchor-point"),
                                  c(
                                        interface_device
                                  )
                              ),
                              str("bypass-queueing-chip"),
                              str("no-bypass-queueing-chip"),
                              c(
                                str("per-unit-scheduler"),
                                str("no-per-unit-scheduler"),
                                str("shared-scheduler"),
                                b(str("hierarchical-scheduler"),
                                    sc(
                                        a(str("maximum-hierarchy-levels"), arg),
                                        a(str("maximum-l2-nodes"), arg),
                                        a(str("maximum-l3-nodes"), arg),
                                        str("implicit-hierarchy")
                                    )
                                ).as(:oneline)
                              ),
                              a(str("l2tp-maximum-session"), arg),
                              a(str("schedulers"), arg),
                              str("interface-transmit-statistics"),
                              str("cascade-port"),
                              str("dce"),
                              c(
                                str("vlan-tagging"),
                                str("stacked-vlan-tagging"),
                                str("flexible-vlan-tagging"),
                                str("vlan-vci-tagging")
                              ),
                              str("hybrid-access"),
                              a(str("native-vlan-id"), arg),
                              str("no-native-vlan-insert"),
                              str("vlan-offload"),
                              b(str("input-native-vlan-push"),
                                (str("disable") | str("enable"))
                              ),
                              str("no-pseudowire-down-on-core-isolation"),
                              b(str("speed"),
                                (str("auto") | str("auto-10m-100m") | str("10m") | str("100m") | str("1g") | str("2.5g") | str("5g") | str("10g") | str("40g") | str("oc3") | str("oc12") | str("oc48"))
                              ),
                              b(str("forwarding-class-accounting"),
                                  c(
                                      b(str("direction"),
                                        (str("ingress") | str("egress") | str("both"))
                                      ),
                                      b(str("enhanced"),
                                          c(
                                              b(str("traffic-type"),
                                                (str("unicast-statistics") | str("multicast-statistics"))
                                              ),
                                              b(str("family"),
                                                (str("inet6") | str("inet") | str("both"))
                                              ),
                                              b(str("direction"),
                                                (str("ingress") | str("egress") | str("both"))
                                              ),
                                              a(str("overhead-bytes"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("auto-configure"),
                                auto_configure_vlan_type
                              ),
                              a(str("mtu"), arg),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline),
                              b(str("damping"),
                                  c(
                                      a(str("half-life"), arg),
                                      a(str("max-suppress"), arg),
                                      a(str("reuse"), arg),
                                      a(str("suppress"), arg),
                                      str("enable")
                                  )
                              ),
                              b(str("link-degrade-monitor"),
                                  c(
                                      b(str("actions"),
                                          c(
                                              c(
                                                str("media-based")
                                              )
                                          )
                                      ),
                                      b(str("recovery"),
                                          c(
                                              a(str("timer"), arg),
                                              c(
                                                str("auto"),
                                                str("manual")
                                              )
                                          )
                                      ),
                                      b(str("thresholds"),
                                          c(
                                              a(str("set"), arg),
                                              a(str("clear"), arg),
                                              a(str("warning-set"), arg),
                                              a(str("warning-clear"), arg),
                                              a(str("interval"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("satop-options"),
                                  c(
                                      a(str("idle-pattern"), arg),
                                      a(str("payload-size"), arg),
                                      b(str("excessive-packet-loss-rate"),
                                          c(
                                              a(str("threshold"), arg),
                                              a(str("sample-period"), arg)
                                          )
                                      ),
                                      c(
                                        a(str("jitter-buffer-packets"), arg),
                                        a(str("jitter-buffer-latency"), arg),
                                        str("jitter-buffer-auto-adjust")
                                      ),
                                      a(str("bit-rate"), arg)
                                  )
                              ),
                              b(str("cesopsn-options"),
                                  c(
                                      a(str("idle-pattern"), arg),
                                      a(str("packetization-latency"), arg),
                                      a(str("payload-size"), arg),
                                      b(str("excessive-packet-loss-rate"),
                                          c(
                                              a(str("threshold"), arg),
                                              a(str("sample-period"), arg)
                                          )
                                      ),
                                      c(
                                        a(str("jitter-buffer-packets"), arg),
                                        a(str("jitter-buffer-latency"), arg),
                                        str("jitter-buffer-auto-adjust")
                                      ),
                                      a(str("bit-rate"), arg)
                                  )
                              ),
                              b(str("ima-group-options"),
                                  c(
                                      b(str("frame-length"),
                                        (str("32") | str("64") | str("128") | str("256"))
                                      ),
                                      b(str("symmetry"),
                                        (str("symmetrical-config-and-operation") | str("symmetrical-config-asymmetrical-operation"))
                                      ),
                                      b(str("transmit-clock"),
                                        (str("common") | str("independent"))
                                      ),
                                      b(str("version"),
                                        (str("1.0") | str("1.1"))
                                      ),
                                      b(str("minimum-links"),
                                          c(
                                              c(
                                                  arg
                                              )
                                          )
                                      ),
                                      b(str("frame-synchronization"),
                                          c(
                                              a(str("alpha"), arg),
                                              a(str("beta"), arg),
                                              a(str("gamma"), arg)
                                          )
                                      ),
                                      b(str("test-procedure"),
                                          c(
                                              a(str("period"), arg),
                                              b(str("interface"),
                                                interface_device
                                              ),
                                              a(str("pattern"), arg)
                                          )
                                      ),
                                      a(str("differential-delay"), arg)
                                  )
                              ),
                              b(str("ima-link-options"),
                                  c(
                                      a(str("group-id"), arg)
                                  )
                              ),
                              b(str("multi-chassis-protection"),
                                multi_chassis_protection_group
                              ),
                              b(str("clocking"),
                                  sc(
                                      c(
                                        str("internal"),
                                        str("external")
                                      )
                                  )
                              ).as(:oneline),
                              b(str("link-mode"),
                                (str("automatic") | str("half-duplex") | str("full-duplex"))
                              ),
                              b(str("media-type"),
                                (str("copper") | str("fiber"))
                              ),
                              b(str("encapsulation"),
                                (str("ethernet-ccc") | str("fddi") | str("token-ring") | str("ppp") | str("ppp-ccc") | str("ppp-tcc") | str("ether-vpls-ppp") | str("frame-relay") | str("frame-relay-ccc") | str("frame-relay-tcc") | str("extended-frame-relay-ccc") | str("extended-frame-relay-tcc") | str("flexible-frame-relay") | str("frame-relay-port-ccc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("extended-frame-relay-ether-type-tcc") | str("cisco-hdlc") | str("cisco-hdlc-ccc") | str("cisco-hdlc-tcc") | str("vlan-ccc") | str("extended-vlan-ccc") | str("ethernet-tcc") | str("flexible-ethernet-services") | str("smds-dxi") | str("atm-pvc") | str("atm-ccc-cell-relay") | str("ethernet-over-atm") | str("ethernet-vpls") | str("extended-vlan-tcc") | str("multilink-frame-relay-uni-nni") | str("satop") | str("cesopsn") | str("ima") | str("ethernet-bridge") | str("ethernet") | str("vlan-vpls") | str("vlan-vci-ccc") | str("extended-vlan-vpls") | str("extended-vlan-bridge") | str("multilink-ppp") | str("generic-services"))
                              ),
                              b(str("esi"),
                                  c(
                                      b(str("auto-derive"),
                                          c(
                                              c(
                                                str("lacp")
                                              )
                                          )
                                      ),
                                        esi,
                                      c(
                                        str("single-active"),
                                        str("all-active")
                                      ),
                                      b(str("df-election-type"),
                                          c(
                                              c(
                                                b(str("preference"),
                                                    c(
                                                        a(str("value"), arg)
                                                    )
                                                )
                                              ),
                                              c(
                                                str("mod")
                                              )
                                          )
                                      ),
                                      b(str("source-bmac"),
                                        mac_unicast
                                      )
                                  )
                              ),
                              b(str("framing"),
                                  c(
                                      c(
                                        str("lan-phy"),
                                        str("wan-phy"),
                                        str("sonet"),
                                        str("sdh")
                                      ),
                                      str("precise-bandwidth")
                                  )
                              ),
                              str("unidirectional"),
                              b(str("lmi"),
                                  c(
                                      a(str("n391dte"), arg),
                                      a(str("n392dce"), arg),
                                      a(str("n392dte"), arg),
                                      a(str("n393dce"), arg),
                                      a(str("n393dte"), arg),
                                      a(str("t391dte"), arg),
                                      a(str("t392dce"), arg),
                                      b(str("lmi-type"),
                                        (str("ansi") | str("itu") | str("c-lmi"))
                                      )
                                  )
                              ),
                              b(str("mlfr-uni-nni-bundle-options"),
                                  c(
                                      b(str("cisco-interoperability"),
                                          c(
                                              str("send-lip-remove-link-for-link-reject")
                                          )
                                      ),
                                      a(str("mrru"), arg),
                                      a(str("yellow-differential-delay"), arg),
                                      a(str("red-differential-delay"), arg),
                                      b(str("action-red-differential-delay"),
                                        (str("remove-link") | str("disable-tx"))
                                      ),
                                      a(str("fragment-threshold"), arg),
                                      a(str("drop-timeout"), arg),
                                      b(str("link-layer-overhead"),
                                        unsigned_float
                                      ),
                                      b(str("lmi-type"),
                                        (str("ansi") | str("itu") | str("c-lmi"))
                                      ),
                                      a(str("minimum-links"), arg),
                                      a(str("hello-timer"), arg),
                                      a(str("acknowledge-timer"), arg),
                                      a(str("acknowledge-retries"), arg),
                                      a(str("n391"), arg),
                                      a(str("n392"), arg),
                                      a(str("n393"), arg),
                                      a(str("t391"), arg),
                                      a(str("t392"), arg)
                                  )
                              ),
                              b(str("mac"),
                                mac_unicast
                              ),
                              b(str("receive-bucket"),
                                dcd_rx_bucket_config
                              ),
                              b(str("transmit-bucket"),
                                dcd_tx_bucket_config
                              ),
                              str("shared-interface"),
                              b(str("sonet-options"),
                                sonet_options_type
                              ),
                              b(str("logical-tunnel-options"),
                                  c(
                                      b(str("link-protection"),
                                          c(
                                              str("revertive"),
                                              str("non-revertive")
                                          )
                                      ),
                                      str("per-unit-mac-disable"),
                                      b(str("load-balance"),
                                        aggregate_load_balance
                                      )
                                  )
                              ),
                              b(str("aggregated-sonet-options"),
                                  c(
                                      a(str("minimum-links"), arg),
                                      b(str("link-speed"),
                                        (str("oc3") | str("oc12") | str("oc48") | str("oc192") | str("oc768") | str("mixed"))
                                      ),
                                      a(str("minimum-bandwidth"), arg)
                                  )
                              ),
                              b(str("atm-options"),
                                  c(
                                      b(str("pic-type"),
                                        (str("atm-ce") | str("atm2") | str("atm1"))
                                      ),
                                      a(str("cell-bundle-size"), arg),
                                      a(str("cell-bundle-timeout"), arg),
                                      str("plp-to-clp"),
                                      str("use-null-cw"),
                                      b(str("promiscuous-mode"),
                                          c(
                                              a(str("vpi"), arg).as(:oneline)
                                          )
                                      ),
                                      b(a(str("vpi"), arg),
                                          c(
                                              a(str("maximum-vcs"), arg),
                                              b(str("shaping"),
                                                dcd_shaping_config
                                              ),
                                              b(str("oam-period"),
                                                  sc(
                                                      ca(
                                                        str("disable").as(:oneline)
                                                      )
                                                  )
                                              ).as(:oneline),
                                              b(str("oam-liveness"),
                                                  c(
                                                      a(str("up-count"), arg),
                                                      a(str("down-count"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      str("ilmi"),
                                      b(a(str("linear-red-profiles"), arg),
                                          sc(
                                              a(str("queue-depth"), arg),
                                              a(str("high-plp-threshold"), arg),
                                              a(str("low-plp-threshold"), arg),
                                              a(str("high-plp-max-threshold"), arg),
                                              a(str("low-plp-max-threshold"), arg)
                                          )
                                      ).as(:oneline),
                                      b(a(str("scheduler-maps"), arg),
                                          c(
                                              b(str("vc-cos-mode"),
                                                (str("strict") | str("alternate"))
                                              ),
                                              b(a(str("forwarding-class"), arg),
                                                  c(
                                                      b(str("priority"),
                                                        (str("low") | str("high"))
                                                      ),
                                                      b(str("transmit-weight"),
                                                          sc(
                                                              c(
                                                                a(str("percent"), arg),
                                                                a(str("cells"), arg)
                                                              )
                                                          )
                                                      ).as(:oneline),
                                                      c(
                                                        b(str("epd-threshold"),
                                                          epd_threshold_config
                                                        ).as(:oneline),
                                                        a(str("linear-red-profile"), arg)
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("mpls"),
                                        mpls_ifd_options
                                      ),
                                      str("payload-scrambler"),
                                      str("no-payload-scrambler")
                                  )
                              ),
                              b(str("multiservice-options"),
                                  c(
                                      str("syslog"),
                                      str("no-syslog"),
                                      str("core-dump"),
                                      str("no-core-dump"),
                                      str("dump-on-flow-control"),
                                      str("no-dump-on-flow-control"),
                                      str("reset-on-flow-control"),
                                      str("no-reset-on-flow-control"),
                                      b(str("flow-control-options"),
                                          c(
                                              str("dump-on-flow-control"),
                                              str("reset-on-flow-control"),
                                              str("down-on-flow-control"),
                                              str("up-on-flow-control")
                                          )
                                      )
                                  )
                              ),
                              b(str("ggsn-options"),
                                  c(
                                      str("syslog"),
                                      str("no-syslog"),
                                      str("core-dump"),
                                      str("no-core-dump")
                                  )
                              ),
                              b(str("ppp-options"),
                                ppp_options_type
                              ),
                              b(str("redundancy-options"),
                                  c(
                                      b(str("primary"),
                                        interface_device
                                      ),
                                      b(str("secondary"),
                                        interface_device
                                      ),
                                      b(str("redundancy-peer"),
                                          c(
                                              b(str("ipaddress"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      b(str("redundancy-local"),
                                          c(
                                              b(str("data-address"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      a(str("routing-instance"), arg),
                                      a(str("replication-threshold"), arg),
                                      b(str("replication-options"),
                                          c(
                                              a(str("mtu"), arg)
                                          )
                                      ),
                                      b(str("replicate-services"),
                                          c(
                                              str("pgcp")
                                          )
                                      )
                                  )
                              ),
                              b(str("load-balancing-options"),
                                  c(
                                      a(str("member-interface"), arg),
                                      b(str("member-failure-options"),
                                          c(
                                              c(
                                                b(str("redistribute-all-traffic"),
                                                    c(
                                                        str("enable-rejoin")
                                                    )
                                                ),
                                                b(str("drop-member-traffic"),
                                                    c(
                                                        a(str("rejoin-timeout"), arg),
                                                        str("enable-rejoin")
                                                    )
                                                )
                                              )
                                          )
                                      ),
                                      b(str("high-availability-options"),
                                          c(
                                              c(
                                                b(str("many-to-one"),
                                                    c(
                                                        b(str("preferred-backup"),
                                                          interface_device
                                                        )
                                                    )
                                                ),
                                                b(str("one-to-one"),
                                                    c(
                                                        b(str("preferred-backup"),
                                                          interface_device
                                                        )
                                                    )
                                                )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("aggregated-inline-services-options"),
                                  c(
                                      b(str("primary-interface"),
                                        interface_device
                                      ),
                                      b(str("secondary-interface"),
                                        interface_device
                                      )
                                  )
                              ),
                              b(str("anchoring-options"),
                                  c(
                                      a(str("apfe-group-set"), arg),
                                      a(str("primary-list"), arg),
                                      b(str("secondary"),
                                          c(
                                              arg
                                          )
                                      ),
                                      c(
                                        str("warm-standby")
                                      )
                                  )
                              ),
                              b(str("lsq-failure-options"),
                                  c(
                                      a(str("trigger-link-failure"), arg),
                                      str("no-termination-request"),
                                      str("no-no-termination-request")
                                  )
                              ),
                              b(str("redundancy-group"),
                                  c(
                                      b(a(str("member-interface"), arg),
                                          c(
                                              c(
                                                str("active"),
                                                str("backup")
                                              )
                                          )
                                      ),
                                      a(str("maximum-links"), arg)
                                  )
                              ),
                              b(str("services-options"),
                                  c(
                                      b(str("syslog"),
                                        log_object
                                      ),
                                      b(str("jflow-log"),
                                          c(
                                              a(str("message-rate-limit"), arg)
                                          )
                                      ),
                                      b(str("deterministic-nat-configuration-log-interval"),
                                          c(
                                              a(str("interval"), arg)
                                          )
                                      ),
                                      a(str("open-timeout"), arg),
                                      a(str("close-timeout"), arg),
                                      a(str("inactivity-timeout"), arg),
                                      a(str("inactivity-tcp-timeout"), arg),
                                      a(str("inactivity-asymm-tcp-timeout"), arg),
                                      a(str("inactivity-non-tcp-timeout"), arg),
                                      a(str("session-timeout"), arg),
                                      str("disable-global-timeout-override"),
                                      a(str("tcp-tickles"), arg),
                                      b(str("trio-flow-offload"),
                                          c(
                                              a(str("minimum-bytes"), arg)
                                          )
                                      ),
                                      a(str("fragment-limit"), arg),
                                      a(str("reassembly-timeout"), arg),
                                      str("cgn-pic"),
                                      a(str("pba-interim-logging-interval"), arg),
                                      b(str("session-limit"),
                                          c(
                                              a(str("maximum"), arg),
                                              a(str("rate"), arg),
                                              a(str("cpu-load-threshold"), arg)
                                          )
                                      ),
                                      str("enable-subscriber-analysis"),
                                      str("disable-usp-tracing"),
                                      str("disable-drop-flows"),
                                      b(str("ignore-errors"),
                                          sc(
                                              str("tcp"),
                                              str("alg")
                                          )
                                      ).as(:oneline),
                                      b(str("capture"),
                                          c(
                                              a(str("capture-size"), arg),
                                              a(str("pkt-size"), arg),
                                              a(str("logs-per-packet"), arg),
                                              a(str("max-log-line-size"), arg),
                                              b(str("filter"),
                                                  c(
                                                      b(str("source-ip"),
                                                          sc(
                                                              b(str("wildcard"),
                                                                ipaddr
                                                              ),
                                                                ipaddr
                                                          )
                                                      ).as(:oneline),
                                                      b(str("dest-ip"),
                                                          sc(
                                                              b(str("wildcard"),
                                                                ipaddr
                                                              ),
                                                                ipaddr
                                                          )
                                                      ).as(:oneline),
                                                      b(str("sw-sip"),
                                                          sc(
                                                              b(str("wildcard"),
                                                                ipv6addr
                                                              ),
                                                                ipv6addr
                                                          )
                                                      ).as(:oneline),
                                                      b(str("sw-dip"),
                                                          sc(
                                                              b(str("wildcard"),
                                                                ipaddr
                                                              ),
                                                                ipaddr
                                                          )
                                                      ).as(:oneline),
                                                      b(str("sport-range"),
                                                          sc(
                                                              a(str("low"), arg),
                                                              a(str("high"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("dport-range"),
                                                          sc(
                                                              a(str("low"), arg),
                                                              a(str("high"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("proto"),
                                                        (str("icmp") | str("tcp") | str("udp"))
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("t3-options"),
                                  c(
                                      b(str("loopback"),
                                        (str("local") | str("remote") | str("payload"))
                                      ),
                                      str("long-buildout"),
                                      str("no-long-buildout"),
                                      str("loop-timing"),
                                      str("no-loop-timing"),
                                      str("unframed"),
                                      str("no-unframed"),
                                      b(str("compatibility-mode"),
                                          sc(
                                              c(
                                                b(str("larscom"),
                                                    sc(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("verilink"),
                                                    sc(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("adtran"),
                                                    sc(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("kentrox"),
                                                    sc(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("digital-link"),
                                                    sc(
                                                        b(str("subrate"),
                                                          (str("301Kb") | str("601Kb") | str("902Kb") | str("1.2Mb") | str("1.5Mb") | str("1.8Mb") | str("2.1Mb") | str("2.4Mb") | str("2.7Mb") | str("3.0Mb") | str("3.3Mb") | str("3.6Mb") | str("3.9Mb") | str("4.2Mb") | str("4.5Mb") | str("4.8Mb") | str("5.1Mb") | str("5.4Mb") | str("5.7Mb") | str("6.0Mb") | str("6.3Mb") | str("6.6Mb") | str("6.9Mb") | str("7.2Mb") | str("7.5Mb") | str("7.8Mb") | str("8.1Mb") | str("8.4Mb") | str("8.7Mb") | str("9.0Mb") | str("9.3Mb") | str("9.6Mb") | str("9.9Mb") | str("10.2Mb") | str("10.5Mb") | str("10.8Mb") | str("11.1Mb") | str("11.4Mb") | str("11.7Mb") | str("12.0Mb") | str("12.3Mb") | str("12.6Mb") | str("12.9Mb") | str("13.2Mb") | str("13.5Mb") | str("13.8Mb") | str("14.1Mb") | str("14.4Mb") | str("14.7Mb") | str("15.0Mb") | str("15.3Mb") | str("15.6Mb") | str("15.9Mb") | str("16.2Mb") | str("16.5Mb") | str("16.8Mb") | str("17.1Mb") | str("17.4Mb") | str("17.7Mb") | str("18.0Mb") | str("18.3Mb") | str("18.6Mb") | str("18.9Mb") | str("19.2Mb") | str("19.5Mb") | str("19.8Mb") | str("20.1Mb") | str("20.5Mb") | str("20.8Mb") | str("21.1Mb") | str("21.4Mb") | str("21.7Mb") | str("22.0Mb") | str("22.3Mb") | str("22.6Mb") | str("22.9Mb") | str("23.2Mb") | str("23.5Mb") | str("23.8Mb") | str("24.1Mb") | str("24.4Mb") | str("24.7Mb") | str("25.0Mb") | str("25.3Mb") | str("25.6Mb") | str("25.9Mb") | str("26.2Mb") | str("26.5Mb") | str("26.8Mb") | str("27.1Mb") | str("27.4Mb") | str("27.7Mb") | str("28.0Mb") | str("28.3Mb") | str("28.6Mb") | str("28.9Mb") | str("29.2Mb") | str("29.5Mb") | str("29.8Mb") | str("30.1Mb") | str("30.4Mb") | str("30.7Mb") | str("31.0Mb") | str("31.3Mb") | str("31.6Mb") | str("31.9Mb") | str("32.2Mb") | str("32.5Mb") | str("32.8Mb") | str("33.1Mb") | str("33.4Mb") | str("33.7Mb") | str("34.0Mb") | str("34.3Mb") | str("34.6Mb") | str("34.9Mb") | str("35.2Mb") | str("35.5Mb") | str("35.8Mb") | str("36.1Mb") | str("36.4Mb") | str("36.7Mb") | str("37.0Mb") | str("37.3Mb") | str("37.6Mb") | str("37.9Mb") | str("38.2Mb") | str("38.5Mb") | str("38.8Mb") | str("39.1Mb") | str("39.4Mb") | str("39.7Mb") | str("40.0Mb") | str("40.3Mb") | str("40.6Mb") | str("40.9Mb") | str("41.2Mb") | str("41.5Mb") | str("41.8Mb") | str("42.1Mb") | str("42.4Mb") | str("42.7Mb") | str("43.0Mb") | str("43.3Mb") | str("43.6Mb") | str("43.9Mb") | str("44.2Mb"))
                                                        )
                                                    )
                                                ).as(:oneline)
                                              )
                                          )
                                      ).as(:oneline),
                                      str("payload-scrambler"),
                                      str("no-payload-scrambler"),
                                      str("cbit-parity"),
                                      str("no-cbit-parity"),
                                      b(str("fcs"),
                                        (str("32") | str("16"))
                                      ),
                                      b(str("idle-cycle-flag"),
                                        (str("flags") | str("ones"))
                                      ),
                                      b(str("start-end-flag"),
                                        (str("shared") | str("filler"))
                                      ),
                                      str("feac-loop-respond"),
                                      str("no-feac-loop-respond"),
                                      b(str("bert-algorithm"),
                                        (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                      ),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg),
                                      a(str("buildout"), arg),
                                      b(str("atm-encapsulation"),
                                        (str("plcp") | str("direct"))
                                      )
                                  )
                              ),
                              b(str("e3-options"),
                                  c(
                                      b(str("loopback"),
                                        (str("local") | str("remote"))
                                      ),
                                      str("unframed"),
                                      str("no-unframed"),
                                      b(str("compatibility-mode"),
                                          sc(
                                              c(
                                                str("larscom"),
                                                b(str("digital-link"),
                                                    sc(
                                                        b(str("subrate"),
                                                          (str("358Kb") | str("716Kb") | str("1.1Mb") | str("1.4Mb") | str("1.8Mb") | str("2.1Mb") | str("2.5Mb") | str("2.9Mb") | str("3.2Mb") | str("3.6Mb") | str("3.9Mb") | str("4.3Mb") | str("4.7Mb") | str("5.0Mb") | str("5.4Mb") | str("5.7Mb") | str("6.1Mb") | str("6.4Mb") | str("6.8Mb") | str("7.2Mb") | str("7.5Mb") | str("7.9Mb") | str("8.2Mb") | str("8.6Mb") | str("9.0Mb") | str("9.3Mb") | str("9.7Mb") | str("10.0Mb") | str("10.4Mb") | str("10.7Mb") | str("11.1Mb") | str("11.5Mb") | str("11.8Mb") | str("12.2Mb") | str("12.5Mb") | str("12.9Mb") | str("13.2Mb") | str("13.6Mb") | str("14.0Mb") | str("14.3Mb") | str("14.7Mb") | str("15.0Mb") | str("15.4Mb") | str("15.8Mb") | str("16.1Mb") | str("16.5Mb") | str("16.8Mb") | str("17.2Mb") | str("17.5Mb") | str("17.9Mb") | str("18.3Mb") | str("18.6Mb") | str("19.0Mb") | str("19.3Mb") | str("19.7Mb") | str("20.0Mb") | str("20.4Mb") | str("20.8Mb") | str("21.1Mb") | str("21.5Mb") | str("21.8Mb") | str("22.2Mb") | str("22.6Mb") | str("22.9Mb") | str("23.3Mb") | str("23.6Mb") | str("24.0Mb") | str("24.3Mb") | str("24.7Mb") | str("25.1Mb") | str("25.4Mb") | str("25.8Mb") | str("26.1Mb") | str("26.5Mb") | str("26.9Mb") | str("27.2Mb") | str("27.6Mb") | str("27.9Mb") | str("28.3Mb") | str("28.6Mb") | str("29.0Mb") | str("29.4Mb") | str("29.7Mb") | str("30.1Mb") | str("30.4Mb") | str("30.8Mb") | str("31.1Mb") | str("31.5Mb") | str("31.9Mb") | str("32.2Mb") | str("32.6Mb") | str("32.9Mb") | str("33.3Mb") | str("33.7Mb") | str("34.0Mb"))
                                                        )
                                                    )
                                                ).as(:oneline),
                                                b(str("kentrox"),
                                                    sc(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline)
                                              )
                                          )
                                      ).as(:oneline),
                                      str("payload-scrambler"),
                                      str("no-payload-scrambler"),
                                      b(str("fcs"),
                                        (str("32") | str("16"))
                                      ),
                                      b(str("idle-cycle-flag"),
                                        (str("flags") | str("ones"))
                                      ),
                                      str("invert-data"),
                                      b(str("start-end-flag"),
                                        (str("shared") | str("filler"))
                                      ),
                                      b(str("bert-algorithm"),
                                        (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                      ),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg),
                                      a(str("buildout"), arg),
                                      b(str("atm-encapsulation"),
                                        (str("plcp") | str("direct"))
                                      ),
                                      b(str("framing"),
                                        (str("g.751") | str("g.832"))
                                      )
                                  )
                              ),
                              b(str("e1-options"),
                                  c(
                                      a(str("timeslots"), arg),
                                      b(str("loopback"),
                                        (str("local") | str("remote"))
                                      ),
                                      b(str("framing"),
                                        (str("g704") | str("unframed") | str("g704-no-crc4"))
                                      ),
                                      b(str("fcs"),
                                        (str("32") | str("16"))
                                      ),
                                      str("invert-data"),
                                      b(str("idle-cycle-flag"),
                                        (str("flags") | str("ones"))
                                      ),
                                      b(str("start-end-flag"),
                                        (str("shared") | str("filler"))
                                      ),
                                      b(str("bert-algorithm"),
                                        (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                      ),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg)
                                  )
                              ),
                              b(str("t1-options"),
                                  c(
                                      a(str("timeslots"), arg),
                                      a(str("voice-timeslots"), arg),
                                      b(str("disable-remote-alarm-detection"),
                                        (str("yellow"))
                                      ),
                                      b(str("loopback"),
                                        (str("local") | str("remote") | str("payload"))
                                      ),
                                      b(str("buildout"),
                                        (str("0-132") | str("133-265") | str("266-398") | str("399-531") | str("532-655") | str("long-0db") | str("long-7.5db") | str("long-15db") | str("long-22.5db"))
                                      ),
                                      b(str("byte-encoding"),
                                        (str("nx64") | str("nx56"))
                                      ),
                                      b(str("line-encoding"),
                                        (str("ami") | str("b8zs"))
                                      ),
                                      str("invert-data"),
                                      b(str("framing"),
                                        (str("sf") | str("esf"))
                                      ),
                                      b(str("fcs"),
                                        (str("32") | str("16"))
                                      ),
                                      b(str("idle-cycle-flag"),
                                        (str("flags") | str("ones"))
                                      ),
                                      b(str("start-end-flag"),
                                        (str("shared") | str("filler"))
                                      ),
                                      b(str("bert-algorithm"),
                                        (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                      ),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg),
                                      str("remote-loopback-respond"),
                                      b(str("crc-major-alarm-threshold"),
                                        (str("1e-3") | str("5e-4") | str("1e-4") | str("5e-5") | str("1e-5"))
                                      ),
                                      b(str("crc-minor-alarm-threshold"),
                                        (str("1e-3") | str("5e-4") | str("1e-4") | str("5e-5") | str("1e-5") | str("5e-6") | str("1e-6"))
                                      ),
                                      b(str("alarm-compliance"),
                                        (str("accunet-t1-5-service"))
                                      )
                                  )
                              ),
                              b(str("ds0-options"),
                                  c(
                                      b(str("loopback"),
                                        (str("payload"))
                                      ),
                                      b(str("byte-encoding"),
                                        (str("nx64") | str("nx56"))
                                      ),
                                      str("invert-data"),
                                      b(str("fcs"),
                                        (str("32") | str("16"))
                                      ),
                                      b(str("idle-cycle-flag"),
                                        (str("flags") | str("ones"))
                                      ),
                                      b(str("start-end-flag"),
                                        (str("shared") | str("filler"))
                                      ),
                                      b(str("bert-algorithm"),
                                        (str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4") | str("repeating-1-in-16"))
                                      ),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg)
                                  )
                              ),
                              b(str("serial-options"),
                                  c(
                                      b(str("line-protocol"),
                                        (str("eia530") | str("v.35") | str("x.21"))
                                      ),
                                      c(
                                        b(str("dte-options"),
                                            c(
                                                str("ignore-all"),
                                                b(str("dtr"),
                                                    sc(
                                                        c(
                                                          str("assert"),
                                                          str("de-assert"),
                                                          str("normal"),
                                                          b(str("auto-synchronize"),
                                                              c(
                                                                  a(str("duration"), arg),
                                                                  a(str("interval"), arg)
                                                              )
                                                          )
                                                        )
                                                    )
                                                ).as(:oneline),
                                                b(str("control-signal"),
                                                  (str("assert") | str("de-assert") | str("normal"))
                                                ),
                                                b(str("rts"),
                                                  (str("assert") | str("de-assert") | str("normal"))
                                                ),
                                                b(str("dcd"),
                                                  (str("require") | str("ignore") | str("normal"))
                                                ),
                                                b(str("dsr"),
                                                  (str("require") | str("ignore") | str("normal"))
                                                ),
                                                b(str("cts"),
                                                  (str("require") | str("ignore") | str("normal"))
                                                ),
                                                b(str("indication"),
                                                  (str("require") | str("ignore") | str("normal"))
                                                ),
                                                b(str("tm"),
                                                  (str("require") | str("ignore") | str("normal"))
                                                )
                                            )
                                        ),
                                        b(str("dce-options"),
                                            c(
                                                str("ignore-all"),
                                                b(str("dtr"),
                                                  (str("require") | str("ignore") | str("normal"))
                                                ),
                                                b(str("rts"),
                                                  (str("require") | str("ignore") | str("normal"))
                                                ),
                                                b(str("dcd"),
                                                  (str("assert") | str("de-assert") | str("normal"))
                                                ),
                                                b(str("dsr"),
                                                  (str("assert") | str("de-assert") | str("normal"))
                                                ),
                                                b(str("cts"),
                                                  (str("assert") | str("de-assert") | str("normal"))
                                                ),
                                                b(str("tm"),
                                                  (str("require") | str("ignore") | str("normal"))
                                                ),
                                                str("dce-loopback-override")
                                            )
                                        )
                                      ),
                                      b(str("dtr-circuit"),
                                        (str("balanced") | str("unbalanced"))
                                      ),
                                      b(str("dtr-polarity"),
                                        (str("positive") | str("negative"))
                                      ),
                                      b(str("rts-polarity"),
                                        (str("positive") | str("negative"))
                                      ),
                                      b(str("control-polarity"),
                                        (str("positive") | str("negative"))
                                      ),
                                      b(str("dcd-polarity"),
                                        (str("positive") | str("negative"))
                                      ),
                                      b(str("dsr-polarity"),
                                        (str("positive") | str("negative"))
                                      ),
                                      b(str("cts-polarity"),
                                        (str("positive") | str("negative"))
                                      ),
                                      b(str("indication-polarity"),
                                        (str("positive") | str("negative"))
                                      ),
                                      b(str("tm-polarity"),
                                        (str("positive") | str("negative"))
                                      ),
                                      b(str("clocking-mode"),
                                        (str("dce") | str("internal") | str("loop"))
                                      ),
                                      b(str("transmit-clock"),
                                        (str("invert"))
                                      ),
                                      b(str("clock-rate"),
                                        (str("2.048mhz") | str("2.341mhz") | str("2.731mhz") | str("3.277mhz") | str("4.096mhz") | str("5.461mhz") | str("8.192mhz") | str("16.384mhz") | str("1.2khz") | str("2.4khz") | str("9.6khz") | str("19.2khz") | str("38.4khz") | str("56.0khz") | str("64.0khz") | str("72.0khz") | str("125.0khz") | str("148.0khz") | str("250.0khz") | str("500.0khz") | str("800.0khz") | str("1.0mhz") | str("1.3mhz") | str("2.0mhz") | str("4.0mhz") | str("8.0mhz"))
                                      ),
                                      b(str("loopback"),
                                        (str("local") | str("remote") | str("dce-local") | str("dce-remote"))
                                      ),
                                      b(str("encoding"),
                                        (str("nrz") | str("nrzi"))
                                      ),
                                      b(str("idle-cycle-flag"),
                                        (str("flags") | str("ones"))
                                      )
                                  )
                              ),
                              str("gratuitous-arp-reply"),
                              str("no-gratuitous-arp-reply"),
                              str("no-gratuitous-arp-request"),
                              str("no-no-gratuitous-arp-request"),
                              str("arp-l2-validate"),
                              b(str("ether-options"),
                                  c(
                                      str("loopback"),
                                      str("no-loopback"),
                                      str("source-filtering"),
                                      str("no-source-filtering"),
                                      b(str("ethernet-switch-profile"),
                                          c(
                                              a(str("tag-protocol-id"), arg),
                                              b(str("ethernet-policer-profile"),
                                                  c(
                                                      b(str("input-priority-map"),
                                                        cos_policer_input_priority_map
                                                      ),
                                                      b(str("output-priority-map"),
                                                        cos_policer_output_priority_map
                                                      ),
                                                      b(str("policer"),
                                                        cos_policer
                                                      )
                                                  )
                                              ),
                                              b(str("storm-control"),
                                                  c(
                                                      arg
                                                  )
                                              ),
                                              b(str("recovery-timeout"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              str("mac-learn-enable"),
                                              str("no-mac-learn-enable")
                                          )
                                      ),
                                      str("asynchronous-notification"),
                                      a(str("source-address-filter"), arg).as(:oneline),
                                      str("auto-negotiation"),
                                      str("no-auto-negotiation"),
                                      str("flow-control"),
                                      str("no-flow-control"),
                                      b(str("configured-flow-control"),
                                          c(
                                              b(str("rx-buffers"),
                                                (str("on") | str("off"))
                                              ),
                                              b(str("tx-buffers"),
                                                (str("on") | str("off"))
                                              )
                                          )
                                      ),
                                      b(str("link-mode"),
                                        (str("automatic") | str("half-duplex") | str("full-duplex"))
                                      ),
                                      b(str("mpls"),
                                        mpls_ifd_options
                                      ),
                                      str("ignore-l3-incompletes"),
                                      str("no-auto-mdix"),
                                      b(str("speed"),
                                          c(
                                              c(
                                                b(str("auto-negotiation"),
                                                    sc(
                                                        str("auto-negotiate-10-100")
                                                    )
                                                ).as(:oneline),
                                                str("ethernet-10m"),
                                                str("ethernet-100m"),
                                                str("ethernet-1g"),
                                                str("ethernet-10g")
                                              )
                                          )
                                      ),
                                      b(str("802.3ad"),
                                          c(
                                              b(str("lacp"),
                                                  c(
                                                      str("force-up"),
                                                      a(str("port-priority"), arg)
                                                  )
                                              ),
                                                interface_device,
                                              c(
                                                str("primary"),
                                                str("backup")
                                              ),
                                              b(str("link-protection-sub-group"),
                                                  c(
                                                        arg
                                                  )
                                              ),
                                              a(str("port-priority"), arg)
                                          )
                                      ),
                                      str("ieee-802-3az-eee"),
                                      b(str("mdi-mode"),
                                        (str("auto") | str("force") | str("mdi") | str("mdix"))
                                      ),
                                      b(str("redundant-parent"),
                                          c(
                                                interface_device
                                          )
                                      ),
                                      str("autostate-exclude")
                                  )
                              ),
                              b(str("fibrechannel-options"),
                                  c(
                                      str("loopback"),
                                      str("no-loopback"),
                                      a(str("bb-sc-n"), arg),
                                      b(str("speed"),
                                        (str("auto-negotiation") | str("1g") | str("2g") | str("4g") | str("8g"))
                                      )
                                  )
                              ),
                              b(str("gigether-options"),
                                  c(
                                      str("loopback"),
                                      str("no-loopback"),
                                      str("loopback-remote"),
                                      str("flow-control"),
                                      str("no-flow-control"),
                                      str("source-filtering"),
                                      str("no-source-filtering"),
                                      c(
                                        str("no-auto-negotiation"),
                                        b(str("auto-negotiation"),
                                            sc(
                                                b(str("remote-fault"),
                                                  (str("local-interface-offline") | str("local-interface-online"))
                                                )
                                            )
                                        ).as(:oneline)
                                      ),
                                      b(str("mac-mode"),
                                        (str("sgmii") | str("mac-mode-1000base-x"))
                                      ),
                                      str("asynchronous-notification"),
                                      a(str("source-address-filter"), arg).as(:oneline),
                                      str("pad-to-minimum-frame-size"),
                                      b(str("redundant-parent"),
                                          c(
                                                interface_device
                                          )
                                      ),
                                      b(str("802.3ad"),
                                          c(
                                              b(str("lacp"),
                                                  c(
                                                      a(str("port-priority"), arg)
                                                  )
                                              ),
                                                interface_device,
                                              a(str("link-index"), arg),
                                              c(
                                                str("primary"),
                                                str("backup")
                                              ),
                                              a(str("distribution-list"), arg)
                                          )
                                      ),
                                      b(str("ethernet-switch-profile"),
                                          c(
                                              a(str("tag-protocol-id"), arg),
                                              b(str("ethernet-policer-profile"),
                                                  c(
                                                      b(str("ieee802.1-priority-map"),
                                                          c(
                                                              a(str("premium"), arg)
                                                          )
                                                      ),
                                                      b(str("input-priority-map"),
                                                        cos_policer_input_priority_map
                                                      ),
                                                      b(str("output-priority-map"),
                                                        cos_policer_output_priority_map
                                                      ),
                                                      b(str("policer"),
                                                        cos_policer
                                                      )
                                                  )
                                              ),
                                              b(str("accept-from"),
                                                  c(
                                                      b(str("mac-address"),
                                                        mac_list
                                                      )
                                                  )
                                              ),
                                              str("reject-the-rest"),
                                              str("no-reject-the-rest"),
                                              str("mac-learn-enable")
                                          )
                                      ),
                                      b(str("mpls"),
                                        mpls_ifd_options
                                      ),
                                      str("ignore-l3-incompletes"),
                                      str("no-auto-mdix"),
                                      str("ieee-802-3az-eee"),
                                      a(str("mru"), arg),
                                      b(str("fec"),
                                        (str("none") | str("fec91") | str("fec74") | str("fec108"))
                                      ),
                                      b(str("speed"),
                                        (str("1g") | str("10g"))
                                      )
                                  )
                              ),
                              b(str("optics-options"),
                                  c(
                                      b(str("wavelength"),
                                        (str("1568.77") | str("1568.36") | str("1568.31") | str("1568.26") | str("1568.21") | str("1568.16") | str("1568.11") | str("1568.05") | str("1568.00") | str("1567.95") | str("1567.90") | str("1567.85") | str("1567.80") | str("1567.75") | str("1567.70") | str("1567.64") | str("1567.59") | str("1567.54") | str("1567.49") | str("1567.44") | str("1567.39") | str("1567.34") | str("1567.29") | str("1567.23") | str("1567.18") | str("1567.13") | str("1567.08") | str("1567.03") | str("1566.98") | str("1566.93") | str("1566.88") | str("1566.83") | str("1566.77") | str("1566.72") | str("1566.67") | str("1566.62") | str("1566.57") | str("1566.52") | str("1566.47") | str("1566.42") | str("1566.36") | str("1566.31") | str("1566.26") | str("1566.21") | str("1566.16") | str("1566.11") | str("1566.06") | str("1566.01") | str("1565.96") | str("1565.90") | str("1565.85") | str("1565.80") | str("1565.75") | str("1565.70") | str("1565.65") | str("1565.60") | str("1565.55") | str("1565.50") | str("1565.44") | str("1565.39") | str("1565.34") | str("1565.29") | str("1565.24") | str("1565.19") | str("1565.14") | str("1565.09") | str("1565.04") | str("1564.99") | str("1564.93") | str("1564.88") | str("1564.83") | str("1564.78") | str("1564.73") | str("1564.68") | str("1564.63") | str("1564.58") | str("1564.53") | str("1564.47") | str("1564.42") | str("1564.37") | str("1564.32") | str("1564.27") | str("1564.22") | str("1564.17") | str("1564.12") | str("1564.07") | str("1564.02") | str("1563.96") | str("1563.91") | str("1563.86") | str("1563.81") | str("1563.76") | str("1563.71") | str("1563.66") | str("1563.61") | str("1563.56") | str("1563.51") | str("1563.45") | str("1563.40") | str("1563.35") | str("1563.30") | str("1563.25") | str("1563.20") | str("1563.15") | str("1563.10") | str("1563.05") | str("1563.00") | str("1562.95") | str("1562.89") | str("1562.84") | str("1562.79") | str("1562.74") | str("1562.69") | str("1562.64") | str("1562.59") | str("1562.54") | str("1562.49") | str("1562.44") | str("1562.39") | str("1562.33") | str("1562.28") | str("1562.23") | str("1562.18") | str("1562.13") | str("1562.08") | str("1562.03") | str("1561.98") | str("1561.93") | str("1561.88") | str("1561.83") | str("1561.77") | str("1561.72") | str("1561.67") | str("1561.62") | str("1561.57") | str("1561.52") | str("1561.47") | str("1561.42") | str("1561.37") | str("1561.32") | str("1561.27") | str("1561.22") | str("1561.16") | str("1561.11") | str("1561.06") | str("1561.01") | str("1560.96") | str("1560.91") | str("1560.86") | str("1560.81") | str("1560.76") | str("1560.71") | str("1560.66") | str("1560.61") | str("1560.56") | str("1560.50") | str("1560.45") | str("1560.40") | str("1560.35") | str("1560.30") | str("1560.25") | str("1560.20") | str("1560.15") | str("1560.10") | str("1560.05") | str("1560.00") | str("1559.95") | str("1559.90") | str("1559.84") | str("1559.79") | str("1559.74") | str("1559.69") | str("1559.64") | str("1559.59") | str("1559.54") | str("1559.49") | str("1559.44") | str("1559.39") | str("1559.34") | str("1559.29") | str("1559.24") | str("1559.19") | str("1559.14") | str("1559.08") | str("1559.03") | str("1558.98") | str("1558.93") | str("1558.88") | str("1558.83") | str("1558.78") | str("1558.73") | str("1558.68") | str("1558.63") | str("1558.58") | str("1558.53") | str("1558.48") | str("1558.43") | str("1558.38") | str("1558.32") | str("1558.27") | str("1558.22") | str("1558.17") | str("1558.12") | str("1558.07") | str("1558.02") | str("1557.97") | str("1557.92") | str("1557.87") | str("1557.82") | str("1557.77") | str("1557.72") | str("1557.67") | str("1557.62") | str("1557.57") | str("1557.52") | str("1557.46") | str("1557.41") | str("1557.36") | str("1557.31") | str("1557.26") | str("1557.21") | str("1557.16") | str("1557.11") | str("1557.06") | str("1557.01") | str("1556.96") | str("1556.91") | str("1556.86") | str("1556.81") | str("1556.76") | str("1556.71") | str("1556.66") | str("1556.61") | str("1556.55") | str("1556.50") | str("1556.45") | str("1556.40") | str("1556.35") | str("1556.30") | str("1556.25") | str("1556.20") | str("1556.15") | str("1556.10") | str("1556.05") | str("1556.00") | str("1555.95") | str("1555.90") | str("1555.85") | str("1555.80") | str("1555.75") | str("1555.70") | str("1555.65") | str("1555.60") | str("1555.55") | str("1555.49") | str("1555.44") | str("1555.39") | str("1555.34") | str("1555.29") | str("1555.24") | str("1555.19") | str("1555.14") | str("1555.09") | str("1555.04") | str("1554.99") | str("1554.94") | str("1554.89") | str("1554.84") | str("1554.79") | str("1554.74") | str("1554.69") | str("1554.64") | str("1554.59") | str("1554.54") | str("1554.49") | str("1554.44") | str("1554.39") | str("1554.34") | str("1554.29") | str("1554.23") | str("1554.18") | str("1554.13") | str("1554.08") | str("1554.03") | str("1553.98") | str("1553.93") | str("1553.88") | str("1553.83") | str("1553.78") | str("1553.73") | str("1553.68") | str("1553.63") | str("1553.58") | str("1553.53") | str("1553.48") | str("1553.43") | str("1553.38") | str("1553.33") | str("1553.28") | str("1553.23") | str("1553.18") | str("1553.13") | str("1553.08") | str("1553.03") | str("1552.98") | str("1552.93") | str("1552.88") | str("1552.83") | str("1552.78") | str("1552.73") | str("1552.68") | str("1552.62") | str("1552.57") | str("1552.52") | str("1552.47") | str("1552.42") | str("1552.37") | str("1552.32") | str("1552.27") | str("1552.22") | str("1552.17") | str("1552.12") | str("1552.07") | str("1552.02") | str("1551.97") | str("1551.92") | str("1551.87") | str("1551.82") | str("1551.77") | str("1551.72") | str("1551.67") | str("1551.62") | str("1551.57") | str("1551.52") | str("1551.47") | str("1551.42") | str("1551.37") | str("1551.32") | str("1551.27") | str("1551.22") | str("1551.17") | str("1551.12") | str("1551.07") | str("1551.02") | str("1550.97") | str("1550.92") | str("1550.87") | str("1550.82") | str("1550.77") | str("1550.72") | str("1550.67") | str("1550.62") | str("1550.57") | str("1550.52") | str("1550.47") | str("1550.42") | str("1550.37") | str("1550.32") | str("1550.27") | str("1550.22") | str("1550.17") | str("1550.12") | str("1550.07") | str("1550.02") | str("1549.97") | str("1549.92") | str("1549.87") | str("1549.82") | str("1549.77") | str("1549.72") | str("1549.67") | str("1549.62") | str("1549.57") | str("1549.52") | str("1549.47") | str("1549.42") | str("1549.37") | str("1549.32") | str("1549.26") | str("1549.21") | str("1549.16") | str("1549.11") | str("1549.06") | str("1549.01") | str("1548.96") | str("1548.91") | str("1548.86") | str("1548.81") | str("1548.76") | str("1548.71") | str("1548.66") | str("1548.61") | str("1548.56") | str("1548.51") | str("1548.46") | str("1548.41") | str("1548.36") | str("1548.31") | str("1548.26") | str("1548.21") | str("1548.16") | str("1548.11") | str("1548.06") | str("1548.02") | str("1547.97") | str("1547.92") | str("1547.87") | str("1547.82") | str("1547.77") | str("1547.72") | str("1547.67") | str("1547.62") | str("1547.57") | str("1547.52") | str("1547.47") | str("1547.42") | str("1547.37") | str("1547.32") | str("1547.27") | str("1547.22") | str("1547.17") | str("1547.12") | str("1547.07") | str("1547.02") | str("1546.97") | str("1546.92") | str("1546.87") | str("1546.82") | str("1546.77") | str("1546.72") | str("1546.67") | str("1546.62") | str("1546.57") | str("1546.52") | str("1546.47") | str("1546.42") | str("1546.37") | str("1546.32") | str("1546.27") | str("1546.22") | str("1546.17") | str("1546.12") | str("1546.07") | str("1546.02") | str("1545.97") | str("1545.92") | str("1545.87") | str("1545.82") | str("1545.77") | str("1545.72") | str("1545.67") | str("1545.62") | str("1545.57") | str("1545.52") | str("1545.47") | str("1545.42") | str("1545.37") | str("1545.32") | str("1545.27") | str("1545.22") | str("1545.17") | str("1545.12") | str("1545.07") | str("1545.02") | str("1544.97") | str("1544.92") | str("1544.87") | str("1544.82") | str("1544.77") | str("1544.72") | str("1544.68") | str("1544.63") | str("1544.58") | str("1544.53") | str("1544.48") | str("1544.43") | str("1544.38") | str("1544.33") | str("1544.28") | str("1544.23") | str("1544.18") | str("1544.13") | str("1544.08") | str("1544.03") | str("1543.98") | str("1543.93") | str("1543.88") | str("1543.83") | str("1543.78") | str("1543.73") | str("1543.68") | str("1543.63") | str("1543.58") | str("1543.53") | str("1543.48") | str("1543.43") | str("1543.38") | str("1543.33") | str("1543.28") | str("1543.23") | str("1543.18") | str("1543.13") | str("1543.08") | str("1543.04") | str("1542.99") | str("1542.94") | str("1542.89") | str("1542.84") | str("1542.79") | str("1542.74") | str("1542.69") | str("1542.64") | str("1542.59") | str("1542.54") | str("1542.49") | str("1542.44") | str("1542.39") | str("1542.34") | str("1542.29") | str("1542.24") | str("1542.19") | str("1542.14") | str("1542.09") | str("1542.04") | str("1541.99") | str("1541.94") | str("1541.89") | str("1541.84") | str("1541.80") | str("1541.75") | str("1541.70") | str("1541.65") | str("1541.60") | str("1541.55") | str("1541.50") | str("1541.45") | str("1541.40") | str("1541.35") | str("1541.30") | str("1541.25") | str("1541.20") | str("1541.15") | str("1541.10") | str("1541.05") | str("1541.00") | str("1540.95") | str("1540.90") | str("1540.85") | str("1540.80") | str("1540.76") | str("1540.71") | str("1540.66") | str("1540.61") | str("1540.56") | str("1540.51") | str("1540.46") | str("1540.41") | str("1540.36") | str("1540.31") | str("1540.26") | str("1540.21") | str("1540.16") | str("1540.11") | str("1540.06") | str("1540.01") | str("1539.96") | str("1539.91") | str("1539.86") | str("1539.82") | str("1539.77") | str("1539.72") | str("1539.67") | str("1539.62") | str("1539.57") | str("1539.52") | str("1539.47") | str("1539.42") | str("1539.37") | str("1539.32") | str("1539.27") | str("1539.22") | str("1539.17") | str("1539.12") | str("1539.07") | str("1539.03") | str("1538.98") | str("1538.93") | str("1538.88") | str("1538.83") | str("1538.78") | str("1538.73") | str("1538.68") | str("1538.63") | str("1538.58") | str("1538.53") | str("1538.48") | str("1538.43") | str("1538.38") | str("1538.33") | str("1538.28") | str("1538.24") | str("1538.19") | str("1538.14") | str("1538.09") | str("1538.04") | str("1537.99") | str("1537.94") | str("1537.89") | str("1537.84") | str("1537.79") | str("1537.74") | str("1537.69") | str("1537.64") | str("1537.59") | str("1537.55") | str("1537.50") | str("1537.45") | str("1537.40") | str("1537.35") | str("1537.30") | str("1537.25") | str("1537.20") | str("1537.15") | str("1537.10") | str("1537.05") | str("1537.00") | str("1536.95") | str("1536.90") | str("1536.86") | str("1536.81") | str("1536.76") | str("1536.71") | str("1536.66") | str("1536.61") | str("1536.56") | str("1536.51") | str("1536.46") | str("1536.41") | str("1536.36") | str("1536.31") | str("1536.26") | str("1536.22") | str("1536.17") | str("1536.12") | str("1536.07") | str("1536.02") | str("1535.97") | str("1535.92") | str("1535.87") | str("1535.82") | str("1535.77") | str("1535.72") | str("1535.67") | str("1535.63") | str("1535.58") | str("1535.53") | str("1535.48") | str("1535.43") | str("1535.38") | str("1535.33") | str("1535.28") | str("1535.23") | str("1535.18") | str("1535.13") | str("1535.08") | str("1535.04") | str("1534.99") | str("1534.94") | str("1534.89") | str("1534.84") | str("1534.79") | str("1534.74") | str("1534.69") | str("1534.64") | str("1534.59") | str("1534.54") | str("1534.50") | str("1534.45") | str("1534.40") | str("1534.35") | str("1534.30") | str("1534.25") | str("1534.20") | str("1534.15") | str("1534.10") | str("1534.05") | str("1534.00") | str("1533.96") | str("1533.91") | str("1533.86") | str("1533.81") | str("1533.76") | str("1533.71") | str("1533.66") | str("1533.61") | str("1533.56") | str("1533.51") | str("1533.47") | str("1533.42") | str("1533.37") | str("1533.32") | str("1533.27") | str("1533.22") | str("1533.17") | str("1533.12") | str("1533.07") | str("1533.02") | str("1532.98") | str("1532.93") | str("1532.88") | str("1532.83") | str("1532.78") | str("1532.73") | str("1532.68") | str("1532.63") | str("1532.58") | str("1532.53") | str("1532.49") | str("1532.44") | str("1532.39") | str("1532.34") | str("1532.29") | str("1532.24") | str("1532.19") | str("1532.14") | str("1532.09") | str("1532.04") | str("1532.00") | str("1531.95") | str("1531.90") | str("1531.85") | str("1531.80") | str("1531.75") | str("1531.70") | str("1531.65") | str("1531.60") | str("1531.56") | str("1531.51") | str("1531.46") | str("1531.41") | str("1531.36") | str("1531.31") | str("1531.26") | str("1531.21") | str("1531.16") | str("1531.12") | str("1531.07") | str("1531.02") | str("1530.97") | str("1530.92") | str("1530.87") | str("1530.82") | str("1530.77") | str("1530.72") | str("1530.68") | str("1530.63") | str("1530.58") | str("1530.53") | str("1530.48") | str("1530.43") | str("1530.38") | str("1530.33") | str("1530.29") | str("1530.24") | str("1530.19") | str("1530.14") | str("1530.09") | str("1530.04") | str("1529.99") | str("1529.94") | str("1529.89") | str("1529.85") | str("1529.80") | str("1529.75") | str("1529.70") | str("1529.65") | str("1529.60") | str("1529.55") | str("1529.50") | str("1529.46") | str("1529.41") | str("1529.36") | str("1529.31") | str("1529.26") | str("1529.21") | str("1529.16") | str("1529.11") | str("1529.07") | str("1529.02") | str("1528.97") | str("1528.92") | str("1528.87") | str("1528.82") | str("1528.77") | str("1528.38"))
                                      ),
                                      a(str("tx-power"), arg),
                                      str("loopback"),
                                      a(str("los-warning-threshold"), arg),
                                      a(str("los-alarm-threshold"), arg),
                                      b(str("modulation-format"),
                                        (str("16qam") | str("8qam") | str("qpsk"))
                                      ),
                                      str("laser-enable"),
                                      str("no-laser-enable"),
                                      str("is-ma"),
                                      str("no-is-ma"),
                                      b(str("encoding"),
                                        (str("differential") | str("non-differential"))
                                      ),
                                      b(str("fec"),
                                        (str("sdfec") | str("sdfec25") | str("hgfec") | str("sdfec15"))
                                      ),
                                      str("high-polarization"),
                                      b(str("signal-degrade"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("ber-threshold-clear"), arg),
                                              a(str("ber-threshold-signal-degrade"), arg),
                                              a(str("q-threshold-signal-degrade-clear"), arg),
                                              a(str("q-threshold-signal-degrade"), arg)
                                          )
                                      ),
                                      a(str("alarm"), enum(str("low-light-alarm")),
                                          c(
                                              c(
                                                str("syslog"),
                                                str("link-down")
                                              )
                                          )
                                      ),
                                      b(str("tca"),
                                          c(
                                              b(str("tx-power-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("tx-power-low-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("rx-power-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("rx-power-low-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("temperature-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("temperature-low-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("carrier-frequency-offset-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("carrier-frequency-offset-low-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("fec-ber"),
                                                  sc(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("tec-current-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("tec-current-low-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("residual-isi-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("residual-isi-low-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("pam-histogram-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("snr-low-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("fec-corrected-errors-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("fec-ucorrected-words-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("laser-frequency-error-high-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              ),
                                              b(str("laser-frequency-error-low-tca"),
                                                  c(
                                                      str("enable-tca"),
                                                      str("no-enable-tca"),
                                                      a(str("threshold"), arg),
                                                      a(str("threshold-24hrs"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      a(str("warning"), enum(str("low-light-warning")),
                                          c(
                                              c(
                                                str("syslog"),
                                                str("link-down")
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("otn-options"),
                                otn_options_type
                              ),
                              b(str("och-options"),
                                och_attributes
                              ),
                              b(str("otu-options"),
                                otu_attributes
                              ),
                              b(str("odu-options"),
                                odu_attributes
                              ),
                              b(str("ett-options"),
                                ett_attributes
                              ),
                              b(str("fastether-options"),
                                  c(
                                      str("loopback"),
                                      str("no-loopback"),
                                      str("flow-control"),
                                      str("no-flow-control"),
                                      str("source-filtering"),
                                      str("no-source-filtering"),
                                      str("auto-negotiation"),
                                      str("no-auto-negotiation"),
                                      a(str("ingress-rate-limit"), arg),
                                      a(str("source-address-filter"), arg).as(:oneline),
                                      b(str("redundant-parent"),
                                          c(
                                                interface_device
                                          )
                                      ),
                                      b(str("802.3ad"),
                                          c(
                                              b(str("lacp"),
                                                  c(
                                                      a(str("port-priority"), arg)
                                                  )
                                              ),
                                                interface_device,
                                              c(
                                                str("primary"),
                                                str("backup")
                                              )
                                          )
                                      ),
                                      b(str("mpls"),
                                        mpls_ifd_options
                                      ),
                                      str("ignore-l3-incompletes")
                                  )
                              ),
                              b(str("redundant-ether-options"),
                                  c(
                                      a(str("redundancy-group"), arg),
                                      str("loopback"),
                                      str("no-loopback"),
                                      str("flow-control"),
                                      str("no-flow-control"),
                                      str("source-filtering"),
                                      str("no-source-filtering"),
                                      a(str("source-address-filter"), arg).as(:oneline),
                                      b(str("link-speed"),
                                        (str("10m") | str("100m") | str("1g") | str("10g"))
                                      ),
                                      a(str("minimum-links"), arg),
                                      b(str("lacp"),
                                          c(
                                              c(
                                                str("active"),
                                                str("passive")
                                              ),
                                              b(str("periodic"),
                                                (str("fast") | str("slow"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("aggregated-ether-options"),
                                  c(
                                      str("loopback"),
                                      str("no-loopback"),
                                      str("flow-control"),
                                      str("no-flow-control"),
                                      str("source-filtering"),
                                      str("no-source-filtering"),
                                      str("autostate-exclude"),
                                      b(str("link-protection"),
                                          c(
                                              str("revertive"),
                                              str("non-revertive"),
                                              b(str("backup-state"),
                                                (str("accept-data") | str("discard-data") | str("down"))
                                              ),
                                              b(str("rtg-config"),
                                                  c(
                                                      a(str("preempt-cutover-timer"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      str("fcoe-lag"),
                                      str("no-fcoe-lag"),
                                      a(str("source-address-filter"), arg).as(:oneline),
                                      b(str("configured-flow-control"),
                                          c(
                                              b(str("rx-buffers"),
                                                (str("on") | str("off"))
                                              ),
                                              b(str("tx-buffers"),
                                                (str("on") | str("off"))
                                              )
                                          )
                                      ),
                                      b(str("load-balance"),
                                        aggregate_load_balance
                                      ),
                                      b(str("bfd-liveness-detection"),
                                          c(
                                              b(str("version"),
                                                (str("0") | str("1") | str("automatic"))
                                              ),
                                              a(str("minimum-interval"), arg),
                                              a(str("minimum-transmit-interval"), arg),
                                              a(str("minimum-receive-interval"), arg),
                                              a(str("multiplier"), arg),
                                              c(
                                                str("no-adaptation")
                                              ),
                                              b(str("transmit-interval"),
                                                  c(
                                                      a(str("minimum-interval"), arg),
                                                      a(str("threshold"), arg)
                                                  )
                                              ),
                                              b(str("detection-time"),
                                                  c(
                                                      a(str("threshold"), arg)
                                                  )
                                              ),
                                              b(str("authentication"),
                                                  c(
                                                      a(str("key-chain"), arg),
                                                      b(str("algorithm"),
                                                        (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                      ),
                                                      str("loose-check")
                                                  )
                                              ),
                                              b(str("neighbor"),
                                                ipaddr
                                              ),
                                              b(str("local-address"),
                                                ipaddr
                                              ),
                                              a(str("holddown-interval"), arg)
                                          )
                                      ),
                                      a(str("minimum-links"), arg),
                                      b(str("minimum-bandwidth"),
                                          c(
                                              a(str("bw-value"), arg),
                                              b(str("bw-unit"),
                                                (str("bps") | str("kbps") | str("mbps") | str("gbps"))
                                              )
                                          )
                                      ),
                                      b(str("targeted-options"),
                                          c(
                                              b(str("type"),
                                                (str("auto") | str("manual"))
                                              ),
                                              c(
                                                str("logical-interface-fpc-redundancy"),
                                                str("logical-interface-chassis-redundancy")
                                              ),
                                              b(str("rebalance-periodic"),
                                                  c(
                                                      b(str("start-time"),
                                                        date
                                                      ),
                                                      a(str("interval"), arg)
                                                  )
                                              ),
                                              a(str("rebalance-subscriber-granularity"), arg)
                                          )
                                      ),
                                      c(
                                        str("logical-interface-fpc-redundancy"),
                                        str("logical-interface-chassis-redundancy")
                                      ),
                                      b(str("rebalance-periodic"),
                                          c(
                                              b(str("start-time"),
                                                date
                                              ),
                                              a(str("interval"), arg)
                                          )
                                      ),
                                      str("pad-to-minimum-frame-size"),
                                      b(str("link-speed"),
                                        (str("10m") | str("100m") | str("1g") | str("2.5g") | str("5g") | str("8g") | str("10g") | str("25g") | str("40g") | str("50g") | str("80g") | str("100g") | str("400g") | str("oc192") | str("mixed"))
                                      ),
                                      b(str("local-bias"),
                                          c(
                                              str("disable")
                                          )
                                      ),
                                      a(str("local-minimum-links-threshold"), arg),
                                      str("resilient-hash"),
                                      b(str("lacp"),
                                          c(
                                              c(
                                                str("active"),
                                                str("passive")
                                              ),
                                              b(str("periodic"),
                                                (str("fast") | str("slow"))
                                              ),
                                              str("fast-failover"),
                                              b(str("link-protection"),
                                                  c(
                                                      str("disable"),
                                                      c(
                                                        str("revertive"),
                                                        str("non-revertive")
                                                      ),
                                                      b(str("rtg-config"),
                                                          c(
                                                              a(str("preempt-cutover-timer"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              str("accept-data"),
                                              b(str("sync-reset"),
                                                (str("disable") | str("enable"))
                                              ),
                                              a(str("system-priority"), arg),
                                              b(str("system-id"),
                                                mac_addr
                                              ),
                                              a(str("admin-key"), arg),
                                              b(str("hold-time"),
                                                  sc(
                                                      a(str("up"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("aggregate-wait-time"), arg),
                                              str("force-up"),
                                              str("no-peer-loopback-validation")
                                          )
                                      ),
                                      b(a(str("link-protection-sub-group"), arg),
                                          c(
                                              c(
                                                str("primary"),
                                                str("backup")
                                              )
                                          )
                                      ),
                                      b(str("ethernet-switch-profile"),
                                          c(
                                              a(str("tag-protocol-id"), arg),
                                              b(str("storm-control"),
                                                  c(
                                                      arg
                                                  )
                                              ),
                                              str("mac-learn-enable")
                                          )
                                      ),
                                      b(str("mc-ae"),
                                          c(
                                              a(str("mc-ae-id"), arg),
                                              a(str("redundancy-group"), arg),
                                              a(str("chassis-id"), arg),
                                              b(str("mode"),
                                                (str("active-standby") | str("active-active"))
                                              ),
                                              b(str("status-control"),
                                                (str("active") | str("standby"))
                                              ),
                                              b(str("switchover-mode"),
                                                (str("revertive") | str("non-revertive"))
                                              ),
                                              a(str("revert-time"), arg),
                                              a(str("init-delay-time"), arg),
                                              a(str("recovery-delay-time"), arg),
                                              str("enhanced-convergence"),
                                              b(str("events"),
                                                  c(
                                                      b(str("iccp-peer-down"),
                                                          c(
                                                              str("force-icl-down"),
                                                              str("prefer-status-control-active")
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      str("share-standby")
                                  )
                              ),
                              b(str("es-options"),
                                  c(
                                      b(str("backup-interface"),
                                        interface_device
                                      )
                                  )
                              ),
                              b(str("dsl-options"),
                                  c(
                                      b(str("operating-mode"),
                                        (str("auto") | str("ansi-dmt") | str("itu-dmt") | str("etsi") | str("itu-annexb-ur2") | str("itu-annexb-non-ur2") | str("itu-dmt-bis") | str("adsl2plus") | str("annexm-itu-dmt-bis") | str("annexm-adsl2plus"))
                                      )
                                  )
                              ),
                              b(str("vdsl-options"),
                                  c(
                                      b(str("vdsl-profile"),
                                        (str("auto") | str("8a") | str("8b") | str("8c") | str("8d") | str("12a") | str("12b") | str("17a"))
                                      ),
                                      b(str("sra"),
                                        (str("enable") | str("disable"))
                                      ),
                                      b(str("v43"),
                                        (str("enable") | str("disable"))
                                      ),
                                      str("sos")
                                  )
                              ),
                              b(str("dsl-sfp-options"),
                                  c(
                                      b(str("adsl-options"),
                                          c(
                                              a(str("vpi"), arg),
                                              a(str("vci"), arg),
                                              b(str("encap"),
                                                (str("bypass") | str("llcsnap-bridged-802dot1q") | str("llcsnap-routed-ip") | str("vc-mux-bridged") | str("vc-mux-routed-ip") | str("generic"))
                                              )
                                          )
                                      ),
                                      b(str("vdsl-options"),
                                          c(
                                              b(str("profile"),
                                                (str("auto") | str("8a") | str("8b") | str("8c") | str("8d") | str("12a") | str("12b") | str("17a") | str("30a"))
                                              ),
                                              b(str("carrier"),
                                                (str("auto") | str("a43") | str("b43"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("shdsl-options"),
                                  c(
                                      b(str("annex"),
                                        (str("annex-a") | str("annex-b") | str("annex-f") | str("annex-g") | str("annex-auto"))
                                      ),
                                      b(str("line-rate"),
                                        (str("auto") | arg)
                                      ),
                                      b(str("loopback"),
                                        (str("local") | str("remote"))
                                      ),
                                      b(str("snr-margin"),
                                          c(
                                              b(str("current"),
                                                (str("disable") | arg)
                                              ),
                                              b(str("snext"),
                                                (str("disable") | arg)
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("data-input"),
                                  c(
                                      c(
                                        str("system"),
                                        b(str("interface"),
                                          interface_device
                                        )
                                      )
                                  )
                              ),
                              b(str("switch-options"),
                                  c(
                                      b(a(str("switch-port"), arg),
                                          c(
                                              str("auto-negotiation"),
                                              str("no-auto-negotiation"),
                                              b(str("link-mode"),
                                                (str("half-duplex") | str("full-duplex"))
                                              ),
                                              b(str("speed"),
                                                (str("10m") | str("100m") | str("1g"))
                                              ),
                                              a(str("vlan-id"), arg),
                                              str("cascade-port")
                                          )
                                      )
                                  )
                              ),
                              b(str("container-options"),
                                  c(
                                      b(str("container-type"),
                                          c(
                                              c(
                                                b(str("aps"),
                                                  aps_type
                                                )
                                              )
                                          )
                                      ),
                                      b(str("member-interface-type"),
                                          c(
                                              c(
                                                b(str("sonet"),
                                                    c(
                                                        b(str("member-interface-speed"),
                                                          (str("oc3") | str("oc12") | str("oc48") | str("oc192") | str("oc768") | str("mixed"))
                                                        )
                                                    )
                                                ),
                                                b(str("atm"),
                                                    c(
                                                        b(str("member-interface-speed"),
                                                          (str("oc3") | str("oc12") | str("oc48"))
                                                        )
                                                    )
                                                ),
                                                b(str("channelized-sonet"),
                                                    c(
                                                        b(str("member-interface-speed"),
                                                          (str("coc3") | str("coc12") | str("coc48") | str("coc192") | str("coc768"))
                                                        )
                                                    )
                                                ),
                                                b(str("channelized-sdh"),
                                                    c(
                                                        b(str("member-interface-speed"),
                                                          (str("cstm1") | str("cstm4") | str("cstm16") | str("coc64") | str("cstm256"))
                                                        )
                                                    )
                                                )
                                              )
                                          )
                                      ),
                                      b(str("redundancy"),
                                          c(
                                              b(str("hold-time"),
                                                  sc(
                                                      a(str("up"), arg),
                                                      a(str("down"), arg)
                                                  )
                                              ).as(:oneline)
                                          )
                                      ),
                                      b(str("container-list"),
                                        interface_device
                                      ),
                                      c(
                                          str("primary"),
                                          str("standby")
                                      ),
                                      str("fast-aps"),
                                      str("allow-configuration-override")
                                  )
                              ),
                              b(str("layer2-policer"),
                                  c(
                                      c(
                                        a(str("input-policer"), arg),
                                        a(str("input-hierarchical-policer"), arg)
                                      )
                                  )
                              ),
                              a(str("unit"), enum(arg | arg | arg),
                                  c(
                                      b(str("policer-overhead"),
                                          ca(
                                              a(str("ingress"), arg),
                                              a(str("egress"), arg)
                                          )
                                      ),
                                      a(str("alias"), arg),
                                      str("enhanced-convergence"),
                                      str("proxy-macip-advertisement"),
                                      str("virtual-gateway-accept-data"),
                                      b(str("peer-psd"),
                                          sc(
                                              arg
                                          )
                                      ).as(:oneline),
                                      b(str("peer-interface"),
                                          c(
                                                interface_unit
                                          )
                                      ),
                                      b(str("interface-shared-with"),
                                          c(
                                              arg
                                          )
                                      ),
                                        (str("disable")),
                                      str("passive-monitor-mode"),
                                      str("per-session-scheduler"),
                                      b(str("account-layer2-overhead"),
                                          ca(
                                              a(str("ingress"), arg),
                                              a(str("egress"), arg)
                                          )
                                      ),
                                      b(str("forwarding-class-accounting"),
                                          c(
                                              b(str("direction"),
                                                (str("ingress") | str("egress") | str("both"))
                                              ),
                                              b(str("enhanced"),
                                                  c(
                                                      b(str("traffic-type"),
                                                        (str("unicast-statistics") | str("multicast-statistics"))
                                                      ),
                                                      b(str("family"),
                                                        (str("inet6") | str("inet") | str("both"))
                                                      ),
                                                      b(str("direction"),
                                                        (str("ingress") | str("egress") | str("both"))
                                                      ),
                                                      a(str("overhead-bytes"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      str("clear-dont-fragment-bit"),
                                      str("packet-inject-enable"),
                                      str("reassemble-packets"),
                                      str("services-options"),
                                      b(str("rpm"),
                                          c(
                                              c(
                                                c(
                                                  str("client"),
                                                  str("server"),
                                                  str("client-delegate-probes")
                                                ),
                                                str("twamp-server"),
                                                str("twamp-client")
                                              )
                                          )
                                      ),
                                      a(str("description"), quote | arg),
                                      a(str("metadata"), arg),
                                      b(str("dial-options"),
                                          c(
                                              c(
                                                a(str("l2tp-interface-id"), arg),
                                                a(str("ipsec-interface-id"), arg)
                                              ),
                                              c(
                                                str("dedicated"),
                                                str("shared")
                                              )
                                          )
                                      ),
                                      str("actual-transit-statistics"),
                                      b(str("demux-source"),
                                            enum((str("inet6") | str("inet")))
                                      ),
                                      b(str("demux-destination"),
                                            enum((str("inet6") | str("inet")))
                                      ),
                                      b(str("demux"),
                                          c(
                                              b(str("inet"),
                                                  c(
                                                      b(str("address"),
                                                        (str("source") | str("destination"))
                                                      ),
                                                      b(str("auto-configure"),
                                                        dynamic_ipv4_type
                                                      )
                                                  )
                                              ),
                                              b(str("inet6"),
                                                  c(
                                                      b(str("address"),
                                                        (str("source") | str("destination"))
                                                      ),
                                                      b(str("auto-configure"),
                                                        dynamic_ipv6_type
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("encapsulation"),
                                        (str("atm-nlpid") | str("atm-cisco-nlpid") | str("atm-snap") | str("atm-vc-mux") | str("atm-ccc-vc-mux") | str("atm-tcc-vc-mux") | str("atm-tcc-snap") | str("atm-ccc-cell-relay") | str("vlan-vci-ccc") | str("ether-over-atm-llc") | str("ether-vpls-over-atm-llc") | str("ppp-over-ether-over-atm-llc") | str("ppp-over-ether") | str("atm-ppp-vc-mux") | str("atm-ppp-llc") | str("atm-mlppp-llc") | str("frame-relay-ppp") | str("frame-relay-ccc") | str("frame-relay") | str("frame-relay-tcc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("ether-vpls-fr") | str("vlan-ccc") | str("ethernet-ccc") | str("vlan-vpls") | str("vlan-bridge") | str("dix") | str("ethernet-vpls") | str("ethernet-bridge") | str("ethernet") | str("vlan") | str("vlan-tcc") | str("multilink-ppp") | str("multilink-frame-relay-end-to-end") | str("ppp-ccc"))
                                      ),
                                      str("gre"),
                                      a(str("mtu"), arg),
                                      c(
                                        str("point-to-point"),
                                        str("multipoint")
                                      ),
                                      a(str("bandwidth"), arg),
                                      a(str("global-layer2-domainid"), arg),
                                      b(str("radio-router"),
                                        dynamic_ifbw_parms_type
                                      ),
                                      str("traps"),
                                      str("no-traps"),
                                      str("routing-services"),
                                      str("no-routing-services"),
                                      b(str("routing-service"),
                                          c(
                                                (str("enable") | str("disable"))
                                          )
                                      ),
                                      b(str("arp-resp"),
                                          sc(
                                              c(
                                                str("unrestricted"),
                                                str("restricted")
                                              )
                                          )
                                      ).as(:oneline),
                                      b(str("proxy-arp"),
                                          sc(
                                              c(
                                                str("unrestricted"),
                                                str("restricted")
                                              )
                                          )
                                      ).as(:oneline),
                                      c(
                                        b(str("vlan-id"),
                                          (str("none") | arg)
                                        ),
                                        a(str("vlan-id-range"), arg),
                                        a(str("inner-vlan-id-swap-ranges"), arg),
                                        a(str("vlan-id-list"), arg),
                                        a(str("vlan-tag"), arg),
                                        b(str("vlan-tags"),
                                            sc(
                                                b(str("outer"),
                                                  (arg | arg | arg)
                                                ),
                                                c(
                                                  b(str("inner"),
                                                    (arg | arg)
                                                  ),
                                                  a(str("inner-range"), arg),
                                                  a(str("inner-list"), arg)
                                                )
                                            )
                                        ).as(:oneline)
                                      ),
                                      a(str("deep-vlan-qualified-learning"), arg),
                                      a(str("native-inner-vlan-id"), arg),
                                      b(str("inner-vlan-id-range"),
                                          sc(
                                              a(str("start"), arg),
                                              a(str("end"), arg)
                                          )
                                      ).as(:oneline),
                                      b(str("accept-source-mac"),
                                          c(
                                              b(str("mac-address"),
                                                mac_list
                                              )
                                          )
                                      ),
                                      b(str("input-vlan-map"),
                                        vlan_map
                                      ),
                                      b(str("output-vlan-map"),
                                        vlan_map
                                      ),
                                      str("swap-by-poppush"),
                                      a(str("receive-lsp"), arg),
                                      a(str("transmit-lsp"), arg),
                                      a(str("dlci"), arg),
                                      a(str("multicast-dlci"), arg),
                                      c(
                                        b(str("vci"),
                                          atm_vci
                                        ),
                                        str("allow-any-vci"),
                                        a(str("vpi"), arg),
                                        a(str("trunk-id"), arg)
                                      ),
                                      str("no-vpivci-swapping"),
                                      c(
                                        b(str("psn-vci"),
                                          atm_vci
                                        ),
                                        a(str("psn-vpi"), arg)
                                      ),
                                      b(str("atm-l2circuit-mode"),
                                          sc(
                                              c(
                                                str("cell"),
                                                str("aal5")
                                              )
                                          )
                                      ).as(:oneline),
                                      b(str("vci-range"),
                                          sc(
                                              a(str("start"), arg),
                                              a(str("end"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("trunk-bandwidth"), arg),
                                      b(str("multicast-vci"),
                                        atm_vci
                                      ),
                                      b(str("shaping"),
                                        dcd_shaping_config
                                      ),
                                      b(str("oam-period"),
                                          sc(
                                              ca(
                                                str("disable").as(:oneline)
                                              )
                                          )
                                      ).as(:oneline),
                                      b(str("oam-liveness"),
                                          c(
                                              a(str("up-count"), arg),
                                              a(str("down-count"), arg)
                                          )
                                      ),
                                      b(str("ppp-options"),
                                        ppp_options_type
                                      ),
                                      b(str("pppoe-options"),
                                        pppoe_options_type
                                      ),
                                      b(str("pppoe-underlying-options"),
                                        pppoe_underlying_options_type
                                      ),
                                      b(str("advisory-options"),
                                        advisory_options_type
                                      ),
                                      b(str("auto-configure"),
                                        auto_configure_vlan_type
                                      ),
                                      b(str("demux-options"),
                                        demux_options_type
                                      ),
                                      b(str("targeted-distribution"),
                                          c(
                                              a(str("primary-list"), arg),
                                              a(str("backup-list"), arg),
                                              a(str("standby-list"), arg)
                                          )
                                      ),
                                      b(str("targeted-options"),
                                          c(
                                              b(str("weight"),
                                                (arg | arg)
                                              ),
                                              b(str("primary"),
                                                interface_device
                                              ),
                                              b(str("backup"),
                                                interface_device
                                              ),
                                              a(str("group"), arg)
                                          )
                                      ),
                                      c(
                                        b(str("keepalives"),
                                          keepalives_type
                                        ).as(:oneline),
                                        str("no-keepalives")
                                      ),
                                      str("inverse-arp"),
                                      a(str("transmit-weight"), arg),
                                      b(str("epd-threshold"),
                                        epd_threshold_config
                                      ).as(:oneline),
                                      a(str("cell-bundle-size"), arg),
                                      a(str("cell-bundle-timeout"), arg),
                                      str("plp-to-clp"),
                                      a(str("atm-scheduler-map"), arg),
                                      a(str("mrru"), arg),
                                      str("short-sequence"),
                                      a(str("fragment-threshold"), arg),
                                      a(str("drop-timeout"), arg),
                                      str("disable-mlppp-inner-ppp-pfc"),
                                      a(str("minimum-links"), arg),
                                      a(str("multilink-max-classes"), arg),
                                      b(str("compression"),
                                          c(
                                              b(str("rtp"),
                                                  c(
                                                      a(str("f-max-period"), arg),
                                                      b(str("queues"),
                                                        (str("q0") | str("q1") | str("q2") | str("q3"))
                                                      ),
                                                      b(str("port"),
                                                          sc(
                                                              a(str("minimum"), arg),
                                                              a(str("maximum"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("maximum-contexts"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              )
                                          )
                                      ),
                                      str("interleave-fragments"),
                                      b(str("link-layer-overhead"),
                                        unsigned_float
                                      ),
                                      a(str("accounting-profile"), arg),
                                      a(str("peer-unit"), arg),
                                      b(str("tunnel"),
                                          c(
                                              b(str("encapsulation"),
                                                  c(
                                                      b(str("vxlan-gpe"),
                                                          c(
                                                              b(str("source"),
                                                                  c(
                                                                      b(str("address"),
                                                                        ipv4addr
                                                                      ),
                                                                      b(str("interface"),
                                                                        interface_name
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("destination"),
                                                                  c(
                                                                      b(str("address"),
                                                                        ipv4addr
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("tunnel-endpoint"),
                                                                (str("vxlan"))
                                                              ),
                                                              a(str("destination-udp-port"), arg),
                                                              a(str("vni"), arg)
                                                          )
                                                      ),
                                                      b(str("udp"),
                                                          c(
                                                              b(str("source"),
                                                                  c(
                                                                      b(str("address"),
                                                                        ipv4addr
                                                                      ),
                                                                      b(str("interface"),
                                                                        interface_name
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("destination"),
                                                                  c(
                                                                      b(str("address"),
                                                                        ipv4addr
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("source"),
                                                ipaddr
                                              ),
                                              b(str("destination"),
                                                ipaddr
                                              ),
                                              a(str("key"), arg),
                                              b(str("backup-destination"),
                                                ipaddr
                                              ),
                                              c(
                                                str("allow-fragmentation"),
                                                str("do-not-fragment")
                                              ),
                                              a(str("ttl"), arg),
                                              a(str("traffic-class"), arg),
                                              a(str("flow-label"), arg),
                                              str("path-mtu-discovery"),
                                              str("no-path-mtu-discovery"),
                                              b(str("routing-instance"),
                                                  c(
                                                      a(str("destination"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("compression-device"),
                                        interface_unit
                                      ),
                                      b(str("atm-policer"),
                                          c(
                                              a(str("input-atm-policer"), arg)
                                          )
                                      ),
                                      b(str("layer2-policer"),
                                          c(
                                              c(
                                                a(str("input-policer"), arg),
                                                a(str("input-hierarchical-policer"), arg),
                                                a(str("input-three-color"), arg)
                                              ),
                                              c(
                                                b(str("output-policer"),
                                                  (arg | arg)
                                                ),
                                                b(str("output-three-color"),
                                                  (arg | arg)
                                                )
                                              )
                                          )
                                      ),
                                      b(str("filter"),
                                          c(
                                              c(
                                                b(str("input"),
                                                    sc(
                                                        arg,
                                                        a(str("shared-name"), arg),
                                                        a(str("precedence"), arg)
                                                    )
                                                ).as(:oneline)
                                              ),
                                              c(
                                                b(str("output"),
                                                    sc(
                                                        arg,
                                                        a(str("shared-name"), arg),
                                                        a(str("precedence"), arg)
                                                    )
                                                ).as(:oneline)
                                              )
                                          )
                                      ),
                                      b(str("multi-chassis-protection"),
                                        multi_chassis_protection_group_ifl
                                      ),
                                      str("statistics"),
                                      b(str("esi"),
                                          c(
                                              b(str("auto-derive"),
                                                  c(
                                                      c(
                                                        str("lacp")
                                                      )
                                                  )
                                              ),
                                                esi,
                                              c(
                                                str("single-active"),
                                                str("all-active")
                                              ),
                                              b(str("df-election-type"),
                                                  c(
                                                      c(
                                                        b(str("preference"),
                                                            c(
                                                                a(str("value"), arg)
                                                            )
                                                        )
                                                      ),
                                                      c(
                                                        str("mod")
                                                      )
                                                  )
                                              ),
                                              b(str("source-bmac"),
                                                mac_unicast
                                              )
                                          )
                                      ),
                                      c(
                                        str("no-auto-virtual-gateway-esi"),
                                        b(str("virtual-gateway-esi"),
                                            c(
                                                  esi,
                                                c(
                                                  str("single-active"),
                                                  str("all-active")
                                                )
                                            )
                                        )
                                      ),
                                      b(str("service"),
                                          c(
                                              b(a(str("pcef"), arg),
                                                  c(
                                                      str("activate-all"),
                                                      a(str("activate"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      str("generate-eui64"),
                                      str("no-generate-eui64"),
                                      b(str("family"),
                                          c(
                                              b(str("inet"),
                                                  c(
                                                      b(str("dhcp"),
                                                        dhcp_client_type
                                                      ),
                                                      b(str("targeted-broadcast"),
                                                          c(
                                                              c(
                                                                str("forward-and-send-to-re"),
                                                                str("forward-only")
                                                              )
                                                          )
                                                      ),
                                                      str("destination-class-usage"),
                                                      str("transit-options-packets"),
                                                      str("transit-ttl-exceeded"),
                                                      str("receive-options-packets"),
                                                      str("receive-ttl-exceeded"),
                                                      b(str("accounting"),
                                                          c(
                                                              b(str("source-class-usage"),
                                                                  c(
                                                                      str("input"),
                                                                      str("output")
                                                                  )
                                                              ),
                                                              str("destination-class-usage")
                                                          )
                                                      ),
                                                      b(str("mac-validate"),
                                                        (str("strict") | str("loose"))
                                                      ),
                                                      b(str("rpf-check"),
                                                          c(
                                                              a(str("fail-filter"), arg),
                                                              b(str("mode"),
                                                                  sc(
                                                                      str("loose")
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ),
                                                      a(str("mtu"), arg),
                                                      a(str("arp-max-cache"), arg),
                                                      a(str("arp-new-hold-limit"), arg),
                                                      a(str("tcp-mss"), arg),
                                                      str("no-redirects"),
                                                      str("no-neighbor-learn"),
                                                      str("unconditional-src-learn"),
                                                      str("multicast-only"),
                                                      str("primary"),
                                                      a(str("ipsec-sa"), arg),
                                                      str("allow-filter-on-re"),
                                                      a(str("demux-source"), arg | arg),
                                                      a(str("demux-destination"), arg | arg),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                b(str("input"),
                                                                    sc(
                                                                        arg,
                                                                        a(str("shared-name"), arg),
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              a(str("input-chain"), arg),
                                                              a(str("output-chain"), arg),
                                                              c(
                                                                b(str("output"),
                                                                    sc(
                                                                        arg,
                                                                        a(str("shared-name"), arg),
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("output-list"), arg)
                                                              ),
                                                              b(str("adf"),
                                                                  c(
                                                                      a(str("rule"), arg),
                                                                      str("counter"),
                                                                      a(str("input-precedence"), arg),
                                                                      str("not-mandatory"),
                                                                      a(str("output-precedence"), arg)
                                                                  )
                                                              ),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      b(str("ingress-queuing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      b(str("iq-policing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      b(str("simple-filter"),
                                                          c(
                                                              a(str("input"), arg)
                                                          )
                                                      ),
                                                      a(str("input-hierarchical-policer"), arg),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("arp"), arg),
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      ),
                                                      b(str("sampling"),
                                                          c(
                                                              str("input"),
                                                              str("output")
                                                          )
                                                      ),
                                                      b(str("service"),
                                                          c(
                                                              b(str("input"),
                                                                  c(
                                                                      b(a(str("service-set"), arg),
                                                                          c(
                                                                              a(str("service-filter"), arg)
                                                                          )
                                                                      ),
                                                                      a(str("post-service-filter"), arg)
                                                                  )
                                                              ),
                                                              b(str("output"),
                                                                  c(
                                                                      b(a(str("service-set"), arg),
                                                                          c(
                                                                              a(str("service-filter"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(a(str("next-hop-tunnel"), arg),
                                                          c(
                                                              a(str("ipsec-vpn"), arg)
                                                          )
                                                      ),
                                                      b(a(str("address"), arg),
                                                          c(
                                                              b(str("destination"),
                                                                ipv4addr
                                                              ),
                                                              a(str("destination-profile"), arg),
                                                              b(str("broadcast"),
                                                                ipv4addr
                                                              ),
                                                              str("primary"),
                                                              str("preferred"),
                                                              str("master-only"),
                                                              b(a(str("multipoint-destination"), arg),
                                                                  c(
                                                                      c(
                                                                        a(str("dlci"), arg),
                                                                        b(str("vci"),
                                                                          atm_vci
                                                                        )
                                                                      ),
                                                                      b(str("shaping"),
                                                                        dcd_shaping_config
                                                                      ),
                                                                      b(str("oam-period"),
                                                                          sc(
                                                                              ca(
                                                                                str("disable").as(:oneline)
                                                                              )
                                                                          )
                                                                      ).as(:oneline),
                                                                      b(str("oam-liveness"),
                                                                          c(
                                                                              a(str("up-count"), arg),
                                                                              a(str("down-count"), arg)
                                                                          )
                                                                      ),
                                                                      str("inverse-arp"),
                                                                      a(str("transmit-weight"), arg),
                                                                      b(str("epd-threshold"),
                                                                        epd_threshold_config
                                                                      ).as(:oneline)
                                                                  )
                                                              ),
                                                              b(a(str("arp"), arg),
                                                                  sc(
                                                                      b(str("l2-interface"),
                                                                        interface_name
                                                                      ),
                                                                      c(
                                                                        b(str("mac"),
                                                                          mac_unicast
                                                                        ),
                                                                        b(str("multicast-mac"),
                                                                          mac_multicast
                                                                        )
                                                                      ),
                                                                      str("publish")
                                                                  )
                                                              ).as(:oneline),
                                                              b(a(str("host-discovery"), arg),
                                                                  sc(
                                                                      a(str("aging-timer"), arg),
                                                                      a(str("discovery-interval"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              b(str("web-authentication"),
                                                                  c(
                                                                      str("https"),
                                                                      str("http"),
                                                                      str("redirect-to-https")
                                                                  )
                                                              ),
                                                              b(str("vrrp-group"),
                                                                vrrp_group
                                                              ),
                                                              b(str("virtual-gateway-address"),
                                                                ipv4addr
                                                              )
                                                          )
                                                      ),
                                                      b(str("unnumbered-address"),
                                                          sc(
                                                                interface_unit,
                                                              b(str("preferred-source-address"),
                                                                (arg | arg)
                                                              ),
                                                              b(str("destination"),
                                                                ipv4addr
                                                              ),
                                                              a(str("destination-profile"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("location-pool-address"),
                                                          c(
                                                                arg
                                                          )
                                                      ),
                                                      str("negotiate-address"),
                                                      a(str("destination-udp-port"), arg)
                                                  )
                                              ),
                                              b(str("iso"),
                                                  c(
                                                      a(str("address"), arg),
                                                      a(str("mtu"), arg),
                                                      a(str("destination-udp-port"), arg)
                                                  )
                                              ),
                                              b(str("inet6"),
                                                  c(
                                                      b(str("dhcpv6-client"),
                                                          c(
                                                              b(str("client-type"),
                                                                (str("stateful") | str("autoconfig"))
                                                              ),
                                                              a(str("client-ia-type"), enum(str("ia-na") | str("ia-pd"))),
                                                              str("rapid-commit"),
                                                              b(str("prefix-delegating"),
                                                                  c(
                                                                      a(str("preferred-prefix-length"), arg),
                                                                      a(str("sub-prefix-length"), arg)
                                                                  )
                                                              ),
                                                              b(str("client-identifier"),
                                                                  sc(
                                                                      b(str("duid-type"),
                                                                        (str("duid-llt") | str("vendor") | str("duid-ll"))
                                                                      )
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("req-option"), enum(str("dns-server") | str("domain") | str("ntp-server") | str("time-zone") | str("sip-server") | str("sip-domain") | str("nis-server") | str("nis-domain") | str("fqdn") | str("vendor-spec") | str("zero-touch-redirect"))),
                                                              b(str("options"),
                                                                  c(
                                                                      b(a(str("number"), arg),
                                                                          sc(
                                                                              c(
                                                                                a(str("hex-string"), arg)
                                                                              )
                                                                          )
                                                                      ).as(:oneline)
                                                                  )
                                                              ),
                                                              a(str("retransmission-attempt"), arg),
                                                              str("no-dns-install"),
                                                              b(str("update-router-advertisement"),
                                                                  c(
                                                                      b(a(str("interface"), arg),
                                                                          c(
                                                                              str("managed-configuration"),
                                                                              str("no-managed-configuration"),
                                                                              str("other-stateful-configuration"),
                                                                              str("no-other-stateful-configuration"),
                                                                              a(str("max-advertisement-interval"), arg),
                                                                              a(str("min-advertisement-interval"), arg),
                                                                              str("enable-recursive-dns-server-option"),
                                                                              str("no-enable-recursive-dns-server-option")
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              str("update-server")
                                                          )
                                                      ),
                                                      b(str("rpf-check"),
                                                          c(
                                                              a(str("fail-filter"), arg),
                                                              b(str("mode"),
                                                                  sc(
                                                                      str("loose")
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ),
                                                      b(str("accounting"),
                                                          c(
                                                              b(str("source-class-usage"),
                                                                  c(
                                                                      str("input"),
                                                                      str("output")
                                                                  )
                                                              ),
                                                              str("destination-class-usage")
                                                          )
                                                      ),
                                                      a(str("mtu"), arg),
                                                      a(str("tcp-mss"), arg),
                                                      a(str("nd6-stale-time"), arg),
                                                      str("no-neighbor-learn"),
                                                      str("slaac-enable"),
                                                      b(str("ndp-proxy"),
                                                          c(
                                                              str("interface-restricted")
                                                          )
                                                      ),
                                                      b(str("dad-proxy"),
                                                          c(
                                                              str("interface-restricted")
                                                          )
                                                      ),
                                                      a(str("nd6-max-cache"), arg),
                                                      a(str("nd6-new-hold-limit"), arg),
                                                      str("no-redirects"),
                                                      str("allow-filter-on-re"),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                b(str("input"),
                                                                    sc(
                                                                        arg,
                                                                        a(str("shared-name"), arg),
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              c(
                                                                b(str("output"),
                                                                    sc(
                                                                        arg,
                                                                        a(str("shared-name"), arg),
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("output-list"), arg)
                                                              ),
                                                              a(str("input-chain"), arg),
                                                              a(str("output-chain"), arg),
                                                              b(str("adf"),
                                                                  c(
                                                                      a(str("rule"), arg),
                                                                      str("counter"),
                                                                      a(str("input-precedence"), arg),
                                                                      str("not-mandatory"),
                                                                      a(str("output-precedence"), arg)
                                                                  )
                                                              ),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      b(str("ingress-queuing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("input-hierarchical-policer"), arg),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      ),
                                                      b(str("sampling"),
                                                          c(
                                                              str("input"),
                                                              str("output")
                                                          )
                                                      ),
                                                      b(str("service"),
                                                          c(
                                                              b(str("input"),
                                                                  c(
                                                                      b(a(str("service-set"), arg),
                                                                          c(
                                                                              a(str("service-filter"), arg)
                                                                          )
                                                                      ),
                                                                      a(str("post-service-filter"), arg)
                                                                  )
                                                              ),
                                                              b(str("output"),
                                                                  c(
                                                                      b(a(str("service-set"), arg),
                                                                          c(
                                                                              a(str("service-filter"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(a(str("address"), arg),
                                                          c(
                                                              b(str("destination"),
                                                                ipv6addr
                                                              ),
                                                              str("eui-64"),
                                                              str("primary"),
                                                              str("preferred"),
                                                              str("master-only"),
                                                              b(a(str("ndp"), arg),
                                                                  sc(
                                                                      b(str("l2-interface"),
                                                                        interface_name
                                                                      ),
                                                                      c(
                                                                        b(str("mac"),
                                                                          mac_unicast
                                                                        ),
                                                                        b(str("multicast-mac"),
                                                                          mac_multicast
                                                                        )
                                                                      ),
                                                                      str("publish")
                                                                  )
                                                              ).as(:oneline),
                                                              b(str("vrrp-inet6-group"),
                                                                vrrp_group
                                                              ),
                                                              b(str("web-authentication"),
                                                                  c(
                                                                      str("https"),
                                                                      str("http"),
                                                                      str("redirect-to-https")
                                                                  )
                                                              ),
                                                              b(str("virtual-gateway-address"),
                                                                ipv6addr
                                                              ),
                                                              str("subnet-router-anycast")
                                                          )
                                                      ),
                                                      a(str("demux-source"), arg | arg | arg),
                                                      a(str("demux-destination"), arg | arg),
                                                      b(str("unnumbered-address"),
                                                          sc(
                                                                interface_unit,
                                                              b(str("preferred-source-address"),
                                                                (arg | arg)
                                                              )
                                                          )
                                                      ).as(:oneline),
                                                      str("dad-disable"),
                                                      str("no-dad-disable"),
                                                      a(str("destination-udp-port"), arg)
                                                  )
                                              ),
                                              b(str("mpls"),
                                                  c(
                                                      a(str("mtu"), arg),
                                                      a(str("maximum-labels"), arg),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                a(str("input"), arg),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              a(str("input-chain"), arg),
                                                              c(
                                                                a(str("output"), arg),
                                                                a(str("output-list"), arg)
                                                              ),
                                                              a(str("output-chain"), arg),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      b(str("ingress-queuing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("input-hierarchical-policer"), arg),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      ),
                                                      a(str("destination-udp-port"), arg)
                                                  )
                                              ),
                                              b(str("mlppp"),
                                                  c(
                                                      b(str("bundle"),
                                                        (arg | arg)
                                                      ),
                                                      c(
                                                        b(str("service-interface"),
                                                          interface_device
                                                        ),
                                                        a(str("service-device-pool"), arg)
                                                      ),
                                                      a(str("dynamic-profile"), arg)
                                                  )
                                              ),
                                              b(str("mlfr-end-to-end"),
                                                  c(
                                                      b(str("bundle"),
                                                        interface_unit
                                                      )
                                                  )
                                              ),
                                              b(str("mlfr-uni-nni"),
                                                  c(
                                                      b(str("bundle"),
                                                        interface_unit
                                                      )
                                                  )
                                              ),
                                              b(str("ccc"),
                                                  c(
                                                      a(str("mtu"), arg),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                a(str("input"), arg),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              a(str("input-chain"), arg),
                                                              c(
                                                                a(str("output"), arg),
                                                                a(str("output-list"), arg)
                                                              ),
                                                              a(str("output-chain"), arg),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      b(str("ingress-queuing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      ),
                                                      str("translate-fecn-and-becn"),
                                                      c(
                                                        str("translate-discard-eligible"),
                                                        str("translate-plp-control-word-de")
                                                      ),
                                                      str("keep-address-and-control")
                                                  )
                                              ),
                                              b(str("tcc"),
                                                  c(
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      ),
                                                      b(str("proxy"),
                                                          c(
                                                              b(str("inet-address"),
                                                                ipv4addr
                                                              )
                                                          )
                                                      ),
                                                      b(str("remote"),
                                                          c(
                                                              b(str("inet-address"),
                                                                ipv4addr
                                                              ),
                                                              b(str("mac-address"),
                                                                mac_addr
                                                              )
                                                          )
                                                      ),
                                                      b(str("protocols"),
                                                        (str("mpls") | str("inet") | str("iso"))
                                                      )
                                                  )
                                              ),
                                              b(str("vpls"),
                                                  c(
                                                      str("core-facing"),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                b(str("input"),
                                                                    sc(
                                                                        arg,
                                                                        a(str("shared-name"), arg),
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              a(str("input-chain"), arg),
                                                              a(str("output-chain"), arg),
                                                              c(
                                                                b(str("output"),
                                                                    sc(
                                                                        arg,
                                                                        a(str("shared-name"), arg),
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("output-list"), arg)
                                                              ),
                                                              b(str("adf"),
                                                                  c(
                                                                      a(str("rule"), arg),
                                                                      str("counter"),
                                                                      a(str("input-precedence"), arg),
                                                                      str("not-mandatory"),
                                                                      a(str("output-precedence"), arg)
                                                                  )
                                                              ),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      b(str("ingress-queuing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      b(str("iq-policing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      ),
                                                      b(str("sampling"),
                                                          c(
                                                              str("input"),
                                                              str("output")
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("bridge"),
                                                  c(
                                                      str("core-facing"),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                b(str("input"),
                                                                    sc(
                                                                        arg,
                                                                        a(str("shared-name"), arg),
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              a(str("input-chain"), arg),
                                                              a(str("output-chain"), arg),
                                                              c(
                                                                b(str("output"),
                                                                    sc(
                                                                        arg,
                                                                        a(str("shared-name"), arg),
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("output-list"), arg)
                                                              ),
                                                              b(str("adf"),
                                                                  c(
                                                                      a(str("rule"), arg),
                                                                      str("counter"),
                                                                      a(str("input-precedence"), arg),
                                                                      str("not-mandatory"),
                                                                      a(str("output-precedence"), arg)
                                                                  )
                                                              ),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      b(str("ingress-queuing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      b(str("iq-policing-filter"),
                                                          sc(
                                                              arg
                                                          )
                                                      ).as(:oneline),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      ),
                                                      b(str("interface-mode"),
                                                        (str("access") | str("trunk"))
                                                      ),
                                                      str("vlan-auto-sense"),
                                                      b(str("bridge-domain-type"),
                                                        (str("svlan") | str("bvlan"))
                                                      ),
                                                      str("inter-switch-link"),
                                                      c(
                                                        a(str("vlan-id"), arg),
                                                        a(str("vlan-id-list"), arg),
                                                        a(str("inner-vlan-id-list"), arg)
                                                      ),
                                                      b(str("vlan-rewrite"),
                                                          c(
                                                              b(a(str("translate"), arg),
                                                                  sc(
                                                                        arg
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ),
                                                      c(
                                                        b(str("isid-list"),
                                                          (str("all-service-groups") | str("all"))
                                                        )
                                                      ),
                                                      b(str("storm-control"),
                                                          c(
                                                              arg
                                                          )
                                                      ),
                                                      b(str("recovery-timeout"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      b(str("sampling"),
                                                          c(
                                                              str("input"),
                                                              str("output")
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("ethernet-switching"),
                                                ethernet_switching_type
                                              ),
                                              b(str("fibre-channel"),
                                                fibre_channel_type
                                              ),
                                              b(str("pppoe"),
                                                pppoe_underlying_options_type
                                              ),
                                              b(str("any"),
                                                  c(
                                                      b(str("filter"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("group"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("service-domain"),
                                        (str("inside") | str("outside"))
                                      ),
                                      str("copy-tos-to-outer-ip-header"),
                                      str("copy-tos-to-outer-ip-header-transit"),
                                      str("force-control-packets-on-transit-path"),
                                      b(str("load-balancing-options"),
                                          c(
                                              b(str("preferred-active"),
                                                interface_device
                                              ),
                                              str("disable-hash"),
                                              b(str("hash-keys"),
                                                  c(
                                                      b(str("ingress-key"),
                                                            enum((str("source-ip") | str("destination-ip") | str("protocol") | str("iif")))
                                                      ),
                                                      b(str("egress-key"),
                                                            enum((str("source-ip") | str("destination-ip") | str("protocol") | str("oif")))
                                                      ),
                                                      b(str("ipv6-source-prefix-length"),
                                                        (str("56") | str("64") | str("96") | str("128"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("mac"),
                                        mac_unicast
                                      ),
                                      b(str("virtual-gateway-v4-mac"),
                                        mac_unicast
                                      ),
                                      b(str("virtual-gateway-v6-mac"),
                                        mac_unicast
                                      ),
                                      b(str("forwarding-options"),
                                          c(
                                              b(str("load-balance-stateful"),
                                                  c(
                                                      str("per-flow"),
                                                      a(str("rebalance"), arg),
                                                      b(str("load-type"),
                                                        (str("high") | str("medium") | str("low"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("etree-ac-role"),
                                        (str("root") | str("leaf"))
                                      )
                                  )
                              ),
                              b(str("no-partition"),
                                  sc(
                                      b(str("interface-type"),
                                        (str("e1") | str("t1") | str("at") | str("t3") | str("e3") | str("ct3") | str("so") | str("cau4"))
                                      )
                                  )
                              ).as(:oneline),
                              b(a(str("partition"), arg),
                                  sc(
                                      a(str("oc-slice"), arg),
                                      a(str("timeslots"), arg),
                                      b(str("interface-type"),
                                        (str("ds") | str("e1") | str("t1") | str("at") | str("ct1") | str("ce1") | str("t3") | str("ct3") | str("e3") | str("so") | str("coc1") | str("cau4") | str("dc") | str("bc"))
                                      )
                                  )
                              ).as(:oneline),
                              b(str("radius-options"),
                                radius_options_vlan_type
                              )
                          )
                      ),
                        interfaces_type
                  )
              ),
              b(str("multi-chassis"),
                  c(
                      b(str("mc-lag"),
                          c(
                              b(str("consistency-check"),
                                  c(
                                      a(str("comparison-delay-time"), arg),
                                      b(str("traceoptions"),
                                          c(
                                              str("no-remote-trace"),
                                              b(str("file"),
                                                  sc(
                                                        arg,
                                                      a(str("size"), arg),
                                                      a(str("files"), arg),
                                                      str("world-readable"),
                                                      str("no-world-readable"),
                                                      b(str("match"),
                                                        regular_expression
                                                      )
                                                  )
                                              ).as(:oneline),
                                              a(str("flag"), enum(str("error") | str("event") | str("packet") | str("pipe") | str("pipe-detail") | str("all"))).as(:oneline)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("multi-chassis-protection"),
                        multi_chassis_protection_group
                      )
                  )
              ),
              b(str("jsrc-partition"),
                  sc(
                        arg
                  )
              ).as(:oneline),
              b(str("snmp"),
                  c(
                      a(str("name"), quote | arg),
                      a(str("description"), quote | arg),
                      a(str("location"), quote | arg),
                      a(str("contact"), quote | arg),
                      b(str("interface"),
                        interface_name
                      ),
                      b(str("alarm-management"),
                          c(
                              b(a(str("alarm-list-name"), arg),
                                  c(
                                      b(a(str("alarm-id"), arg),
                                          c(
                                              b(a(str("alarm-state"), arg),
                                                  c(
                                                      a(str("notification-id"), arg),
                                                      a(str("varbind-index"), arg),
                                                      a(str("varbind-value"), arg),
                                                      a(str("description"), quote | arg),
                                                      a(str("varbind-subtree"), arg),
                                                      a(str("resource-prefix"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("filter-interfaces"),
                          c(
                              a(str("interfaces"), arg),
                              str("all-internal-interfaces")
                          )
                      ),
                      str("if-count-with-filter-interfaces"),
                      str("filter-duplicates"),
                      b(str("nonvolatile"),
                          c(
                              a(str("commit-delay"), arg)
                          )
                      ),
                      b(str("v3"),
                          c(
                              b(str("usm"),
                                  c(
                                      b(str("local-engine"),
                                          c(
                                              b(str("user"),
                                                v3_user_config
                                              )
                                          )
                                      ),
                                      b(a(str("remote-engine"), arg),
                                          c(
                                              b(str("user"),
                                                v3_user_config
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("vacm"),
                                  c(
                                      b(str("security-to-group"),
                                          c(
                                              a(str("security-model"), enum(str("usm") | str("v1") | str("v2c")),
                                                  c(
                                                      b(a(str("security-name"), arg),
                                                          c(
                                                              a(str("group"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("access"),
                                          c(
                                              b(a(str("group"), arg),
                                                  c(
                                                      b(str("default-context-prefix"),
                                                          c(
                                                              b(str("security-model"),
                                                                security_model_access
                                                              )
                                                          )
                                                      ),
                                                      b(a(str("context-prefix"), arg),
                                                          c(
                                                              b(str("security-model"),
                                                                security_model_access
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("target-address"), arg),
                                  c(
                                      b(str("address"),
                                        ipaddr
                                      ),
                                      a(str("port"), arg),
                                      a(str("timeout"), arg),
                                      a(str("retry-count"), arg),
                                      a(str("tag-list"), arg),
                                      b(str("address-mask"),
                                        ipaddr
                                      ),
                                      a(str("routing-instance"), arg),
                                      a(str("logical-system"), arg),
                                      a(str("target-parameters"), arg)
                                  )
                              ),
                              b(a(str("target-parameters"), arg),
                                  c(
                                      b(str("parameters"),
                                          c(
                                              b(str("message-processing-model"),
                                                (str("v1") | str("v2c") | str("v3"))
                                              ),
                                              b(str("security-model"),
                                                (str("usm") | str("v1") | str("v2c"))
                                              ),
                                              b(str("security-level"),
                                                (str("none") | str("authentication") | str("privacy"))
                                              ),
                                              a(str("security-name"), arg)
                                          )
                                      ),
                                      b(str("notify-filter"),
                                          sc(
                                                arg
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(a(str("notify"), arg),
                                  c(
                                      b(str("type"),
                                        (str("trap") | str("inform"))
                                      ),
                                      a(str("tag"), arg)
                                  )
                              ),
                              b(a(str("notify-filter"), arg),
                                  c(
                                      b(a(str("oid"), arg),
                                          sc(
                                              c(
                                                str("include"),
                                                str("exclude")
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(a(str("snmp-community"), arg),
                                  c(
                                      b(str("community-name"),
                                        unreadable
                                      ),
                                      a(str("security-name"), arg),
                                      a(str("context"), arg),
                                      a(str("tag"), arg)
                                  )
                              )
                          )
                      ),
                      b(a(str("proxy"), arg),
                          c(
                              a(str("device-name"), arg),
                              c(
                                b(str("version-v1"),
                                  comm_object
                                ),
                                b(str("version-v2c"),
                                  comm_object
                                ),
                                b(str("version-v3"),
                                  sec_object
                                )
                              ),
                              a(str("routing-instance"), arg),
                              b(a(str("logical-system"), arg),
                                  c(
                                      a(str("routing-instance"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("subagent"),
                          c(
                              b(str("tcp"),
                                  c(
                                      b(str("routing-instance"),
                                          c(
                                              str("default")
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("engine-id"),
                          c(
                              c(
                                str("use-mac-address"),
                                str("use-default-ip-address"),
                                a(str("local"), arg)
                              )
                          )
                      ),
                      b(str("access"),
                          c(
                              b(a(str("user"), arg),
                                  c(
                                      b(str("authentication-type"),
                                        (str("none") | str("md5") | str("sha"))
                                      ),
                                      b(str("authentication-password"),
                                        unreadable
                                      ),
                                      b(str("privacy-type"),
                                        (str("none") | str("des"))
                                      ),
                                      b(str("privacy-password"),
                                        unreadable
                                      ),
                                      b(a(str("clients"), arg),
                                          sc(
                                              str("restrict")
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(a(str("group"), arg),
                                  c(
                                      a(str("user"), arg),
                                      b(str("model"),
                                        (str("usm"))
                                      )
                                  )
                              ),
                              b(a(str("context"), arg),
                                  c(
                                      a(str("description"), quote | arg),
                                      b(a(str("group"), arg),
                                          c(
                                              b(str("model"),
                                                (str("usm"))
                                              ),
                                              b(str("security-level"),
                                                (str("none") | str("authentication") | str("privacy"))
                                              ),
                                              a(str("read-view"), arg),
                                              a(str("write-view"), arg)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(a(str("view"), arg),
                          c(
                              b(a(str("oid"), arg),
                                  sc(
                                      c(
                                        str("include"),
                                        str("exclude")
                                      )
                                  )
                              ).as(:oneline)
                          )
                      ),
                      b(a(str("client-list"), arg),
                          c(
                                client_address_object
                          )
                      ),
                      b(a(str("community"), arg),
                          c(
                              a(str("view"), arg),
                              b(str("authorization"),
                                (str("read-only") | str("read-write"))
                              ),
                              c(
                                a(str("client-list-name"), arg),
                                b(a(str("clients"), arg),
                                    sc(
                                        str("restrict")
                                    )
                                ).as(:oneline)
                              ),
                              b(a(str("routing-instances"), arg),
                                  c(
                                      c(
                                        a(str("client-list-name"), arg),
                                        b(a(str("clients"), arg),
                                            sc(
                                                str("restrict")
                                            )
                                        ).as(:oneline)
                                      )
                                  )
                              ),
                              b(a(str("routing-instance"), arg),
                                  c(
                                      c(
                                        a(str("client-list-name"), arg),
                                        b(a(str("clients"), arg),
                                            sc(
                                                str("restrict")
                                            )
                                        ).as(:oneline)
                                      )
                                  )
                              ),
                              b(a(str("logical-system"), arg),
                                  c(
                                      b(a(str("routing-instance"), arg),
                                          c(
                                              c(
                                                a(str("client-list-name"), arg),
                                                b(a(str("clients"), arg),
                                                    sc(
                                                        str("restrict")
                                                    )
                                                ).as(:oneline)
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("trap-options"),
                          c(
                              b(str("source-address"),
                                  c(
                                      c(
                                        str("lo0"),
                                          ipaddr
                                      )
                                  )
                              ),
                              str("enterprise-oid"),
                              str("context-oid"),
                              b(a(str("routing-instances"), arg),
                                  c(
                                      b(str("source-address"),
                                          c(
                                              c(
                                                str("lo0"),
                                                  ipaddr
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("routing-instance"), arg),
                                  c(
                                      b(str("source-address"),
                                          c(
                                              c(
                                                str("lo0"),
                                                  ipaddr
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("logical-system"), arg),
                                  c(
                                      b(a(str("routing-instance"), arg),
                                          c(
                                              b(str("source-address"),
                                                  c(
                                                      c(
                                                        str("lo0"),
                                                          ipaddr
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("agent-address"),
                                (str("outgoing-interface"))
                              )
                          )
                      ),
                      b(a(str("trap-group"), arg),
                          c(
                              b(str("version"),
                                (str("all") | str("v1") | str("v2"))
                              ),
                              a(str("destination-port"), arg),
                              b(str("categories"),
                                  c(
                                      str("authentication"),
                                      str("chassis"),
                                      str("link"),
                                      str("remote-operations"),
                                      str("routing"),
                                      str("startup"),
                                      str("ggsn"),
                                      str("rmon-alarm"),
                                      str("vrrp-events"),
                                      str("configuration"),
                                      str("services"),
                                      str("chassis-cluster"),
                                      str("timing-events"),
                                      str("dot3oam-events"),
                                      b(str("sonet-alarms"),
                                          c(
                                              str("loss-of-light"),
                                              str("pll-lock"),
                                              str("loss-of-frame"),
                                              str("loss-of-signal"),
                                              str("severely-errored-frame"),
                                              str("line-ais"),
                                              str("path-ais"),
                                              str("loss-of-pointer"),
                                              str("ber-defect"),
                                              str("ber-fault"),
                                              str("line-remote-defect-indication"),
                                              str("path-remote-defect-indication"),
                                              str("remote-error-indication"),
                                              str("unequipped"),
                                              str("path-mismatch"),
                                              str("loss-of-cell"),
                                              str("vt-ais"),
                                              str("vt-loss-of-pointer"),
                                              str("vt-remote-defect-indication"),
                                              str("vt-unequipped"),
                                              str("vt-label-mismatch"),
                                              str("vt-loss-of-cell")
                                          )
                                      ),
                                      b(str("otn-alarms"),
                                          c(
                                              str("oc-los"),
                                              str("oc-lof"),
                                              str("oc-lom"),
                                              str("wavelength-lock"),
                                              str("otu-ais"),
                                              str("otu-bdi"),
                                              str("otu-ttim"),
                                              str("otu-iae"),
                                              str("otu-sd"),
                                              str("otu-sf"),
                                              str("otu-fec-exe"),
                                              str("otu-fec-deg"),
                                              str("otu-bbe-threshold"),
                                              str("otu-es-threshold"),
                                              str("otu-ses-threshold"),
                                              str("otu-uas-threshold"),
                                              str("odu-ais"),
                                              str("odu-oci"),
                                              str("odu-lck"),
                                              str("odu-bdi"),
                                              str("odu-ttim"),
                                              str("odu-sd"),
                                              str("odu-sf"),
                                              str("odu-rx-aps-change"),
                                              str("odu-bbe-threshold"),
                                              str("odu-es-threshold"),
                                              str("odu-ses-threshold"),
                                              str("odu-uas-threshold"),
                                              str("opu-ptm")
                                          )
                                      )
                                  )
                              ),
                              a(str("targets"), arg).as(:oneline),
                              a(str("routing-instance"), arg),
                              a(str("logical-system"), arg)
                          )
                      ),
                      b(str("routing-instance-access"),
                          c(
                              b(a(str("access-list"), arg),
                                  sc(
                                      str("restrict")
                                  )
                              ).as(:oneline)
                          )
                      ),
                      str("logical-system-trap-filter"),
                      b(str("traceoptions"),
                          c(
                              b(str("memory-trace"),
                                  c(
                                      a(str("size"), arg)
                                  )
                              ),
                              str("no-remote-trace"),
                              b(str("file"),
                                  sc(
                                      a(str("size"), arg),
                                      a(str("files"), arg),
                                      str("world-readable"),
                                      str("no-world-readable"),
                                      b(str("match"),
                                        regular_expression
                                      )
                                  )
                              ).as(:oneline),
                              a(str("flag"), enum(str("timer") | str("protocol-timeouts") | str("pdu") | str("varbind-error") | str("routing-socket") | str("interface-stats") | str("subagent") | str("general") | str("nonvolatile-sets") | str("all"))).as(:oneline)
                          )
                      ),
                      b(str("rmon"),
                          c(
                              b(a(str("history"), arg),
                                  c(
                                      b(str("interface"),
                                        interface_name
                                      ),
                                      a(str("bucket-size"), arg),
                                      a(str("interval"), arg),
                                      a(str("owner"), arg)
                                  )
                              ),
                              b(a(str("alarm"), arg),
                                  c(
                                      a(str("description"), quote | arg),
                                      a(str("interval"), arg),
                                      a(str("falling-threshold-interval"), arg),
                                      a(str("variable"), arg),
                                      b(str("sample-type"),
                                        (str("absolute-value") | str("delta-value"))
                                      ),
                                      b(str("request-type"),
                                        (str("get-request") | str("get-next-request") | str("walk-request"))
                                      ),
                                      b(str("startup-alarm"),
                                        (str("rising-alarm") | str("falling-alarm") | str("rising-or-falling-alarm"))
                                      ),
                                      a(str("rising-threshold"), arg),
                                      a(str("falling-threshold"), arg),
                                      a(str("rising-event-index"), arg),
                                      a(str("falling-event-index"), arg),
                                      a(str("syslog-subtag"), arg)
                                  )
                              ),
                              b(a(str("event"), arg),
                                  c(
                                      a(str("description"), quote | arg),
                                      b(str("type"),
                                        (str("none") | str("log") | str("snmptrap") | str("log-and-trap"))
                                      ),
                                      a(str("community"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("health-monitor"),
                          c(
                              b(str("routing-engine"),
                                  c(
                                      b(str("cpu"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("moderate-threshold"), arg),
                                              a(str("high-threshold"), arg),
                                              a(str("critical-threshold"), arg),
                                              b(str("action"),
                                                (str("monitor") | str("prevent") | str("recover"))
                                              )
                                          )
                                      ),
                                      b(str("memory"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("moderate-threshold"), arg),
                                              a(str("high-threshold"), arg),
                                              a(str("critical-threshold"), arg),
                                              b(str("action"),
                                                (str("monitor") | str("prevent") | str("recover"))
                                              )
                                          )
                                      ),
                                      b(str("storage"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("moderate-threshold"), arg),
                                              a(str("high-threshold"), arg),
                                              a(str("critical-threshold"), arg),
                                              b(str("action"),
                                                (str("monitor") | str("prevent") | str("recover"))
                                              )
                                          )
                                      ),
                                      b(str("temperature"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("moderate-threshold"), arg),
                                              a(str("high-threshold"), arg),
                                              a(str("critical-threshold"), arg)
                                          )
                                      ),
                                      b(str("process-count"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("moderate-threshold"), arg),
                                              a(str("high-threshold"), arg),
                                              a(str("critical-threshold"), arg),
                                              b(str("action"),
                                                (str("monitor") | str("prevent") | str("recover"))
                                              )
                                          )
                                      ),
                                      b(str("open-files-count"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("moderate-threshold"), arg),
                                              a(str("high-threshold"), arg),
                                              a(str("critical-threshold"), arg),
                                              b(str("action"),
                                                (str("monitor") | str("prevent") | str("recover"))
                                              )
                                          )
                                      ),
                                      a(str("interval"), arg),
                                      a(str("moderate-threshold"), arg),
                                      a(str("high-threshold"), arg),
                                      a(str("critical-threshold"), arg),
                                      b(str("action"),
                                        (str("monitor") | str("prevent") | str("recover"))
                                      ),
                                      b(str("traceoptions"),
                                          c(
                                              b(str("file"),
                                                  sc(
                                                        arg,
                                                      a(str("size"), arg),
                                                      a(str("files"), arg),
                                                      str("world-readable"),
                                                      str("no-world-readable")
                                                  )
                                              ).as(:oneline),
                                              a(str("flag"), enum(str("configuration") | str("memory") | str("diagnostic") | str("all"))).as(:oneline)
                                          )
                                      )
                                  )
                              ),
                              a(str("interval"), arg),
                              a(str("rising-threshold"), arg),
                              a(str("falling-threshold"), arg),
                              b(str("idp"),
                                  c(
                                      a(str("interval"), arg),
                                      a(str("rising-threshold"), arg),
                                      a(str("falling-threshold"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("arp"),
                          c(
                              str("host-name-resolution")
                          )
                      ),
                      b(str("customization"),
                          c(
                              str("ether-stats-ifd-only")
                          )
                      )
                  )
              ),
              b(str("forwarding-options"),
                juniper_forwarding_options
              ),
              b(str("event-options"),
                  c(
                      a(str("max-policies"), arg),
                      b(a(str("generate-event"), arg),
                          sc(
                              c(
                                b(str("time-of-day"),
                                  date
                                ),
                                a(str("time-interval"), arg)
                              ),
                              str("no-drift")
                          )
                      ).as(:oneline),
                      b(a(str("policy"), arg),
                          c(
                              a(str("events"), arg),
                              b(a(str("within"), arg),
                                  c(
                                      b(str("trigger"),
                                          sc(
                                              c(
                                                str("until"),
                                                str("on"),
                                                str("after")
                                              ),
                                              arg
                                          )
                                      ).as(:oneline),
                                      a(str("events"), arg),
                                      b(str("not"),
                                          sc(
                                              a(str("events"), arg)
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(str("attributes-match"),
                                  s(
                                          arg,
                                          enum((str("equals") | str("starts-with") | str("matches"))),
                                          arg
                                  )
                              ).as(:oneline),
                              b(str("then"),
                                  c(
                                      str("ignore"),
                                      b(str("priority-override"),
                                          c(
                                              b(str("facility"),
                                                (str("authorization") | str("daemon") | str("ftp") | str("ntp") | str("security") | str("kernel") | str("user") | str("dfc") | str("external") | str("firewall") | str("pfe") | str("conflict-log") | str("change-log") | str("interactive-commands"))
                                              ),
                                              b(str("severity"),
                                                (str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("info"))
                                              )
                                          )
                                      ),
                                      b(str("upload"),
                                          s(
                                            arg,
                                            a(str("destination"), arg),
                                            c(
                                              a(str("user-name"), arg),
                                              a(str("transfer-delay"), arg),
                                              b(str("retry-count"),
                                                  sc(
                                                        arg,
                                                      a(str("retry-interval"), arg)
                                                  )
                                              ).as(:oneline)
                                            )
                                          )
                                      ),
                                      b(str("change-configuration"),
                                          c(
                                              b(str("retry"),
                                                  sc(
                                                      a(str("count"), arg),
                                                      a(str("interval"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("commands"), arg),
                                              a(str("user-name"), arg),
                                              b(str("commit-options"),
                                                  c(
                                                      b(str("check"),
                                                          c(
                                                              str("synchronize")
                                                          )
                                                      ),
                                                      str("synchronize"),
                                                      str("force"),
                                                      a(str("log"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("execute-commands"),
                                          c(
                                              a(str("commands"), arg),
                                              a(str("user-name"), arg),
                                              a(str("output-filename"), arg),
                                              b(a(str("destination"), arg),
                                                  c(
                                                      a(str("transfer-delay"), arg),
                                                      b(str("retry-count"),
                                                          sc(
                                                                arg,
                                                              a(str("retry-interval"), arg)
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              ),
                                              b(str("output-format"),
                                                (str("text") | str("xml"))
                                              )
                                          )
                                      ),
                                      b(a(str("event-script"), arg),
                                          c(
                                              b(a(str("arguments"), arg),
                                                  sc(
                                                      arg
                                                  )
                                              ).as(:oneline),
                                              a(str("user-name"), arg),
                                              a(str("output-filename"), arg),
                                              b(a(str("destination"), arg),
                                                  c(
                                                      a(str("transfer-delay"), arg),
                                                      b(str("retry-count"),
                                                          sc(
                                                                arg,
                                                              a(str("retry-interval"), arg)
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              ),
                                              b(str("output-format"),
                                                (str("text") | str("xml"))
                                              )
                                          )
                                      ),
                                      str("raise-trap")
                                  )
                              )
                          )
                      ),
                      b(str("event-script"),
                          c(
                              str("optional"),
                              a(str("max-datasize"), arg),
                              b(str("dampen"),
                                  c(
                                      b(str("dampen-options"),
                                          c(
                                              a(str("cpu-factor"), arg),
                                              a(str("line-interval"), arg),
                                              a(str("time-interval"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sc(
                                                arg,
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable")
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), enum(str("events") | str("input") | str("offline") | str("output") | str("rpc") | str("xslt") | str("all"))).as(:oneline)
                                  )
                              ),
                              b(a(str("file"), arg),
                                  c(
                                      a(str("source"), arg),
                                      a(str("python-script-user"), arg),
                                      b(str("dampen"),
                                          c(
                                              b(str("dampen-options"),
                                                  c(
                                                      a(str("cpu-factor"), arg),
                                                      a(str("line-interval"), arg),
                                                      a(str("time-interval"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      a(str("routing-instance"), arg),
                                      str("refresh"),
                                      a(str("refresh-from"), arg),
                                      b(str("checksum"),
                                          c(
                                              a(str("sha-256"), arg)
                                          )
                                      ),
                                      b(a(str("remote-execution"), arg),
                                          c(
                                              a(str("username"), arg),
                                              b(str("passphrase"),
                                                unreadable
                                              )
                                          )
                                      )
                                  )
                              ),
                              str("refresh"),
                              a(str("refresh-from"), arg)
                          )
                      ),
                      b(a(str("destinations"), arg),
                          c(
                              a(str("transfer-delay"), arg),
                              b(a(str("archive-sites"), arg),
                                  sc(
                                      b(str("password"),
                                        unreadable
                                      )
                                  )
                              ).as(:oneline)
                          )
                      ),
                      b(str("traceoptions"),
                          c(
                              str("no-remote-trace"),
                              b(str("file"),
                                  sc(
                                        arg,
                                      a(str("size"), arg),
                                      a(str("files"), arg),
                                      str("world-readable"),
                                      str("no-world-readable"),
                                      b(str("match"),
                                        regular_expression
                                      )
                                  )
                              ).as(:oneline),
                              a(str("flag"), enum(str("server") | str("configuration") | str("events") | str("timer-events") | str("database") | str("policy") | str("registration") | str("syslogd") | str("all"))).as(:oneline)
                          )
                      ),
                      b(str("redundancy-event"),
                        srd_events_object
                      )
                  )
              ),
              b(str("accounting-options"),
                juniper_accounting_options
              ),
              b(str("policy-options"),
                juniper_policy_options
              ),
              b(str("class-of-service"),
                juniper_class_of_service_options
              ),
              b(str("firewall"),
                  c(
                      b(str("family"),
                          c(
                              b(str("inet"),
                                  c(
                                      b(str("dialer-filter"),
                                        inet_dialer_filter
                                      ),
                                      b(str("prefix-action"),
                                        prefix_action
                                      ),
                                      b(str("filter"),
                                        inet_filter
                                      ),
                                      b(str("template"),
                                        inet_template
                                      ),
                                      b(str("simple-filter"),
                                        inet_simple_filter
                                      ),
                                      b(str("service-filter"),
                                        inet_service_filter
                                      ),
                                      b(str("fast-update-filter"),
                                        inet_fuf
                                      )
                                  )
                              ),
                              b(str("inet6"),
                                  c(
                                      b(str("dialer-filter"),
                                        inet6_dialer_filter
                                      ),
                                      b(str("filter"),
                                        inet6_filter
                                      ),
                                      b(str("service-filter"),
                                        inet6_service_filter
                                      ),
                                      b(str("fast-update-filter"),
                                        inet6_fuf
                                      ),
                                      b(str("template"),
                                        inet6_template
                                      )
                                  )
                              ),
                              b(str("mpls"),
                                  c(
                                      b(str("dialer-filter"),
                                        mpls_dialer_filter
                                      ),
                                      b(str("filter"),
                                        mpls_filter
                                      ),
                                      b(str("template"),
                                        mpls_template
                                      )
                                  )
                              ),
                              b(str("vpls"),
                                  c(
                                      b(str("filter"),
                                        vpls_filter
                                      )
                                  )
                              ),
                              b(str("evpn"),
                                  c(
                                      b(str("filter"),
                                        vpls_filter
                                      )
                                  )
                              ),
                              b(str("bridge"),
                                  c(
                                      b(str("filter"),
                                        bridge_filter
                                      )
                                  )
                              ),
                              b(str("ccc"),
                                  c(
                                      b(str("filter"),
                                        ccc_filter
                                      )
                                  )
                              ),
                              b(str("any"),
                                  c(
                                      b(str("filter"),
                                        any_filter
                                      ),
                                      b(str("template"),
                                        any_template
                                      )
                                  )
                              ),
                              b(str("ethernet-switching"),
                                  c(
                                      b(str("filter"),
                                        es_filter
                                      ),
                                      b(str("template"),
                                        es_template
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("policer"),
                        firewall_policer
                      ),
                      b(str("flexible-match"),
                        firewall_flexible_match
                      ),
                      b(str("tunnel-end-point"),
                        tunnel_end_point
                      ),
                      b(str("hierarchical-policer"),
                        firewall_hierpolicer
                      ),
                      b(str("interface-set"),
                        interface_set_type
                      ),
                      b(str("load-balance-group"),
                        firewall_load_balance_group
                      ),
                      b(str("atm-policer"),
                        atm_policer_type
                      ),
                      b(str("three-color-policer"),
                        three_color_policer_type
                      ),
                      b(str("filter"),
                        inet_filter
                      )
                  )
              ),
              b(str("access"),
                juniper_access_options
              ),
              b(str("routing-instances"),
                  c(
                        juniper_routing_instance
                  )
              ),
              b(str("tenants"),
                juniper_tenant
              ),
              b(str("unified-edge"),
                  c(
                      b(str("cos-cac"),
                        juniper_unified_edge_cos_options
                      ),
                      b(a(str("local-policies"), arg),
                          c(
                              a(str("description"), quote | arg),
                              a(str("resource-threshold-profile"), arg),
                              a(str("classifier-profile"), arg),
                              a(str("cos-policy-profile"), arg),
                              a(str("roamer-classifier-profile"), arg),
                              a(str("roamer-cos-policy-profile"), arg),
                              a(str("visitor-classifier-profile"), arg),
                              a(str("visitor-cos-policy-profile"), arg),
                              a(str("traffic-class-qci-mapping-profile"), arg),
                              a(str("ul-bandwidth-pool"), arg),
                              a(str("dl-bandwidth-pool"), arg)
                          )
                      ),
                      b(str("aaa"),
                          c(
                              b(str("traceoptions"),
                                aaa_traceoptions
                              ),
                              b(str("profiles"),
                                aaa_profile
                              )
                          )
                      ),
                      b(str("diameter-profiles"),
                        mobile_diameter_profiles
                      ),
                      b(str("gateways"),
                          c(
                              b(a(str("ggsn-pgw"), arg),
                                  c(
                                      b(str("service-mode"),
                                        (str("maintenance"))
                                      ),
                                      a(str("maximum-bearers"), arg),
                                      a(str("session-timeout-check-interval"), arg),
                                      a(str("redirect-timeout"), arg),
                                      a(str("local-policy-profile"), arg),
                                      b(str("pfes"),
                                          c(
                                              a(str("guaranteed-bandwidth"), arg),
                                              a(str("maximum-bearers"), arg),
                                              a(str("default-bearers-percentage"), arg),
                                              a(str("ipv4-nbm-prefixes"), arg),
                                              a(str("ipv6-nbm-prefixes"), arg),
                                              a(str("maximum-sdfs"), arg)
                                          )
                                      ),
                                      a(str("anchor-pfe-guaranteed-bandwidth"), arg),
                                      a(str("anchor-pfe-maximum-bearers"), arg),
                                      a(str("anchor-pfe-default-bearers-percentage"), arg),
                                      a(str("anchor-pfe-ipv4-nbm-prefixes"), arg),
                                      a(str("anchor-pfe-ipv6-nbm-prefixes"), arg),
                                      b(str("preemption"),
                                          c(
                                              str("enable"),
                                              str("gtpv1-pvi-disable"),
                                              str("gtpv1-pci-disable")
                                          )
                                      ),
                                      b(str("gtp"),
                                        mobile_gateway_config_gtp
                                      ),
                                      b(str("home-plmn"),
                                          c(
                                              b(str("mcc"),
                                                  s(
                                                          arg,
                                                    a(str("mnc"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("traceoptions"),
                                        mobile_smd_traceoptions
                                      ),
                                      b(str("call-rate-statistics"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("history"), arg)
                                          )
                                      ),
                                      b(a(str("service-selection-profiles"), arg),
                                          c(
                                              b(a(str("term"), arg),
                                                  c(
                                                      b(str("from"),
                                                          c(
                                                              a(str("imsi"), arg),
                                                              a(str("msisdn"), arg),
                                                              a(str("imei"), arg),
                                                              str("anonymous-user"),
                                                              a(str("domain-name"), arg),
                                                              b(str("roaming-status"),
                                                                (str("home") | str("roamer") | str("visitor"))
                                                              ),
                                                              b(str("plmn"),
                                                                  c(
                                                                      b(str("mcc"),
                                                                          s(
                                                                                  arg,
                                                                            a(str("mnc"), arg)
                                                                          )
                                                                      ),
                                                                      str("except")
                                                                  )
                                                              ),
                                                              a(str("charging-characteristics"), arg),
                                                              a(str("maximum-bearers"), arg),
                                                              b(str("peer"),
                                                                ipaddr
                                                              ),
                                                              a(str("peer-routing-instance"), arg),
                                                              b(str("pdn-type"),
                                                                (str("ipv4") | str("ipv6") | str("ipv4v6"))
                                                              ),
                                                              b(str("rat-type"),
                                                                (str("geran") | str("utran") | str("eutran") | str("wlan") | str("hspa"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("then"),
                                                          c(
                                                              a(str("redirect-peer"), arg).as(:oneline),
                                                              str("accept"),
                                                              str("reject"),
                                                              a(str("apn-name"), arg),
                                                              a(str("pcef-profile"), arg),
                                                              a(str("charging-profile"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("apn-services"),
                                        ggsn_pgw_apn_services
                                      ),
                                      b(str("system"),
                                        unified_edge_ggsn_pgw_system
                                      ),
                                      b(str("diameter"),
                                        unified_edge_gateway_diameter
                                      ),
                                      b(str("charging"),
                                          c(
                                              b(str("traceoptions"),
                                                charging_traceoptions
                                              ),
                                              b(str("charging-profiles"),
                                                  c(
                                                        juniper_charging_profiles
                                                  )
                                              ),
                                              b(str("transport-profiles"),
                                                  c(
                                                        juniper_transport_profiles
                                                  )
                                              ),
                                              b(str("cdr-profiles"),
                                                  c(
                                                        juniper_cdr_profiles
                                                  )
                                              ),
                                              b(str("trigger-profiles"),
                                                  c(
                                                        juniper_trigger_profiles
                                                  )
                                              ),
                                              b(str("local-persistent-storage-options"),
                                                juniper_charged_configuraton
                                              ),
                                              b(str("gtpp"),
                                                  c(
                                                      b(str("source-interface"),
                                                          sc(
                                                                interface_name,
                                                              b(str("ipv4-address"),
                                                                ipv4addr
                                                              )
                                                          )
                                                      ).as(:oneline),
                                                      a(str("destination-port"), arg),
                                                      a(str("n3-requests"), arg),
                                                      b(str("transport-protocol"),
                                                        (str("udp") | str("tcp"))
                                                      ),
                                                      b(str("version"),
                                                        (str("v0") | str("v1") | str("v2"))
                                                      ),
                                                      a(str("echo-interval"), arg),
                                                      str("no-path-management"),
                                                      a(str("t3-response"), arg),
                                                      b(str("header-type"),
                                                        (str("short") | str("long"))
                                                      ),
                                                      a(str("pending-queue-size"), arg),
                                                      a(str("down-detect-time"), arg),
                                                      a(str("reconnect-time"), arg),
                                                      b(str("peer"),
                                                        gtpp_peer
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("ip-reassembly-profile"),
                                          c(
                                                arg
                                          )
                                      ),
                                      b(str("ipv6-router-advertisement"),
                                        mobile_gateways_ipv6_router_advertisement
                                      ),
                                      b(str("software-datapath"),
                                          c(
                                              b(str("traceoptions"),
                                                software_datapath_traceoptions
                                              )
                                          )
                                      ),
                                      b(str("inline-services"),
                                          c(
                                              b(str("ip-reassembly"),
                                                  c(
                                                      b(str("service-set"),
                                                          c(
                                                                arg
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("sgw"), arg),
                                  c(
                                      b(str("service-mode"),
                                        (str("maintenance"))
                                      ),
                                      a(str("maximum-bearers"), arg),
                                      a(str("local-policy-profile"), arg),
                                      b(str("pfes"),
                                          c(
                                              a(str("guaranteed-bandwidth"), arg),
                                              a(str("maximum-bearers"), arg),
                                              a(str("default-bearers-percentage"), arg)
                                          )
                                      ),
                                      a(str("anchor-pfe-guaranteed-bandwidth"), arg),
                                      a(str("anchor-pfe-maximum-bearers"), arg),
                                      a(str("anchor-pfe-default-bearers-percentage"), arg),
                                      b(str("preemption"),
                                          c(
                                              str("enable")
                                          )
                                      ),
                                      str("remote-delete-on-peer-fail"),
                                      b(str("gtp"),
                                        sgw_config_gtp
                                      ),
                                      b(str("home-plmn"),
                                          c(
                                              b(str("mcc"),
                                                  s(
                                                          arg,
                                                    a(str("mnc"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("traceoptions"),
                                        mobile_smd_traceoptions
                                      ),
                                      b(str("call-rate-statistics"),
                                          c(
                                              a(str("interval"), arg),
                                              a(str("history"), arg)
                                          )
                                      ),
                                      b(str("system"),
                                        unified_edge_sgw_system
                                      ),
                                      b(str("charging"),
                                          c(
                                              b(str("traceoptions"),
                                                charging_traceoptions
                                              ),
                                              b(str("charging-profiles"),
                                                  c(
                                                        juniper_charging_profiles
                                                  )
                                              ),
                                              b(str("transport-profiles"),
                                                  c(
                                                        juniper_transport_profiles
                                                  )
                                              ),
                                              b(str("cdr-profiles"),
                                                  c(
                                                        juniper_cdr_profiles
                                                  )
                                              ),
                                              b(str("trigger-profiles"),
                                                  c(
                                                        juniper_trigger_profiles
                                                  )
                                              ),
                                              b(str("local-persistent-storage-options"),
                                                juniper_charged_configuraton
                                              ),
                                              b(str("gtpp"),
                                                  c(
                                                      b(str("source-interface"),
                                                          sc(
                                                                interface_name,
                                                              b(str("ipv4-address"),
                                                                ipv4addr
                                                              )
                                                          )
                                                      ).as(:oneline),
                                                      a(str("destination-port"), arg),
                                                      a(str("n3-requests"), arg),
                                                      b(str("transport-protocol"),
                                                        (str("udp") | str("tcp"))
                                                      ),
                                                      b(str("version"),
                                                        (str("v0") | str("v1") | str("v2"))
                                                      ),
                                                      a(str("echo-interval"), arg),
                                                      str("no-path-management"),
                                                      a(str("t3-response"), arg),
                                                      b(str("header-type"),
                                                        (str("short") | str("long"))
                                                      ),
                                                      a(str("pending-queue-size"), arg),
                                                      a(str("down-detect-time"), arg),
                                                      a(str("reconnect-time"), arg),
                                                      b(str("peer"),
                                                        gtpp_peer
                                                      )
                                                  )
                                              ),
                                              b(str("global-profile"),
                                                  c(
                                                      a(str("default-profile"), arg),
                                                      a(str("home-profile"), arg),
                                                      a(str("roamer-profile"), arg),
                                                      a(str("visitor-profile"), arg),
                                                      b(str("profile-selection-order"),
                                                        (str("static") | str("serving") | str("pgw-cg-addr"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("ip-reassembly-profile"),
                                          c(
                                                arg
                                          )
                                      ),
                                      b(str("idle-mode-buffering"),
                                        sgw_idle_mode_buffering
                                      ),
                                      b(str("software-datapath"),
                                          c(
                                              b(str("traceoptions"),
                                                software_datapath_traceoptions
                                              )
                                          )
                                      ),
                                      b(str("inline-services"),
                                          c(
                                              b(str("ip-reassembly"),
                                                  c(
                                                      b(str("service-set"),
                                                          c(
                                                                arg
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("tdf"),
                                unified_edge_tdf
                              )
                          )
                      ),
                      b(str("mobile-options"),
                        unified_edge_mobile_options
                      ),
                      b(str("pcef"),
                        unified_edge_pcef
                      ),
                      b(str("resource-management"),
                          c(
                              b(str("server"),
                                  c(
                                      b(str("traceoptions"),
                                        rmpsd_traceoptions_type
                                      )
                                  )
                              ),
                              b(str("client"),
                                  c(
                                      b(str("traceoptions"),
                                        rmps_clnt_traceoptions_type
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("jsrc"),
                jsrc_options
              ),
              b(str("vmhost"),
                  c(
                      str("no-auto-recovery"),
                      b(str("management-if"),
                          c(
                              b(str("link-mode"),
                                (str("automatic") | str("half-duplex") | str("full-duplex"))
                              ),
                              b(str("speed"),
                                (str("automatic") | str("10m") | str("100m") | str("1g"))
                              ),
                              str("disable")
                          )
                      ),
                      b(str("resize"),
                          c(
                              b(str("vjunos"),
                                  c(
                                      str("compact")
                                  )
                              )
                          )
                      ),
                      a(str("interfaces"), str("management-if0") | str("management-if1"),
                          c(
                              b(str("family"),
                                  c(
                                      b(str("inet"),
                                          c(
                                              b(a(str("address"), arg),
                                                  c(
                                                      str("master-only")
                                                  )
                                              ),
                                              b(str("gateway"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      b(str("inet6"),
                                          c(
                                              b(a(str("address"), arg),
                                                  c(
                                                      str("master-only")
                                                  )
                                              ),
                                              b(str("gateway"),
                                                ipv6addr
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("syslog"),
                          c(
                              b(a(str("file"), arg),
                                  c(
                                          s(
                                                  enum((str("any") | str("authorization") | str("privileged") | str("cron") | str("daemon") | str("kernel") | str("lpr") | str("mail") | str("mark") | str("news") | str("syslog") | str("user") | str("uucp") | str("local0") | str("local1") | str("local2") | str("local3") | str("local4") | str("local5") | str("local6") | str("local7"))),
                                                  enum((str("any") | str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("none")))
                                          ).as(:oneline)
                                  )
                              ),
                              b(a(str("host"), arg),
                                  c(
                                          s(
                                                  enum((str("any") | str("authorization") | str("privileged") | str("cron") | str("daemon") | str("kernel") | str("lpr") | str("mail") | str("mark") | str("news") | str("syslog") | str("user") | str("uucp") | str("local0") | str("local1") | str("local2") | str("local3") | str("local4") | str("local5") | str("local6") | str("local7"))),
                                                  enum((str("any") | str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("none")))
                                          ).as(:oneline),
                                      b(str("transport"),
                                        (str("tcp") | str("udp"))
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("services"),
                          c(
                              b(str("ssh"),
                                  c(
                                      b(str("root-login"),
                                        (str("allow") | str("deny"))
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("applications"),
                  c(
                      b(str("application"),
                        application_object
                      ),
                      b(str("application-set"),
                        application_set_object
                      )
                  )
              ),
              b(str("diameter"),
                  c(
                      b(str("origin"),
                          c(
                              a(str("realm"), arg),
                              a(str("host"), arg)
                          )
                      ),
                      b(a(str("network-element"), arg),
                          c(
                              b(str("dne-origin"),
                                  c(
                                      a(str("realm"), arg),
                                      a(str("host"), arg)
                                  )
                              ),
                              b(str("function"),
                                (str("jsrc") | str("gx-plus") | str("sd-3gpp") | str("nasreq") | str("pcrf") | str("ocs") | str("s6a"))
                              ),
                              b(a(str("peer"), arg),
                                  c(
                                      a(str("priority"), arg)
                                  )
                              ),
                              b(str("forwarding"),
                                  c(
                                      b(a(str("route"), arg),
                                          c(
                                              b(str("function"),
                                                  sc(
                                                      c(
                                                        str("jsrc"),
                                                        str("gx-plus"),
                                                        str("sd-3gpp"),
                                                        str("nasreq"),
                                                        str("pcrf"),
                                                        str("ocs"),
                                                        str("s6a")
                                                      ),
                                                      a(str("partition"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("destination"),
                                                  sc(
                                                      a(str("realm"), arg),
                                                      a(str("host"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("metric"), arg)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(a(str("transport"), arg),
                          c(
                              b(str("address"),
                                ipaddr
                              ),
                              c(
                                b(str("logical-system"),
                                    sc(
                                        arg,
                                        a(str("routing-instance"), arg)
                                    )
                                ).as(:oneline),
                                a(str("routing-instance"), arg)
                              )
                          )
                      ),
                      b(a(str("peer"), arg),
                          c(
                              b(str("address"),
                                ipaddr
                              ),
                              str("send-origin-state-id"),
                              c(
                                b(str("logical-system"),
                                    sc(
                                        arg,
                                        a(str("routing-instance"), arg)
                                    )
                                ).as(:oneline),
                                a(str("routing-instance"), arg)
                              ),
                              b(str("connect-actively"),
                                  c(
                                      a(str("transport"), arg),
                                      a(str("port"), arg)
                                  )
                              ),
                              b(str("peer-origin"),
                                  c(
                                      a(str("realm"), arg),
                                      a(str("host"), arg)
                                  )
                              )
                          )
                      ),
                      a(str("product-name"), arg)
                  )
              ),
              b(str("poe"),
                  c(
                      b(str("management"),
                        (str("static") | str("class") | str("high-power"))
                      ),
                      a(str("guard-band"), arg),
                      b(str("notification-control"),
                          c(
                              b(a(str("fpc"), arg),
                                  c(
                                      str("disable")
                                  )
                              )
                          )
                      ),
                      str("lldp-priority"),
                      a(str("interface"), str("all") | str("all-extended") | arg,
                          c(
                              str("disable"),
                              b(str("priority"),
                                (str("low") | str("high"))
                              ),
                              a(str("maximum-power"), arg),
                              b(str("telemetries"),
                                  c(
                                      str("disable"),
                                      a(str("interval"), arg),
                                      a(str("duration"), arg)
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("routing-options"),
                juniper_routing_options
              ),
              b(str("protocols"),
                juniper_protocols
              ),
              b(str("dynamic-profiles"),
                juniper_dynamic_profile_object
              ),
              b(str("bridge-domains"),
                  c(
                        juniper_bridge_domains
                  )
              ),
              b(str("fabric"),
                  c(
                      b(str("routing-instances"),
                          c(
                                juniper_fabric_routing_instance
                          )
                      ),
                      b(str("routing-options"),
                        juniper_fabric_routing_options
                      ),
                      b(str("protocols"),
                          c(
                              b(str("bgp"),
                                juniper_protocols_bgp
                              )
                          )
                      ),
                      b(str("virtual-chassis"),
                          c(
                              b(str("flow-groups"),
                                  c(
                                        flow_group_type,
                                      b(a(str("node-device"), arg),
                                          c(
                                              b(a(str("interconnect-device"), arg),
                                                  c(
                                                      b(str("preference"),
                                                        (str("high") | str("normal") | str("never"))
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("traceoptions"),
                                juniper_virtual_chassis_traceoptions
                              )
                          )
                      )
                  )
              ),
              b(str("multicast-snooping-options"),
                juniper_multicast_snooping_options
              ),
              b(str("switch-options"),
                juniper_def_rtb_switch_options
              ),
              b(a(str("session-limit-group"), arg),
                  sc(
                      a(str("maximum-sessions"), arg)
                  )
              ).as(:oneline),
              b(str("virtual-chassis"),
                  c(
                      b(str("auto-sw-update"),
                          c(
                              a(str("package-name"), arg),
                              b(str("ex-4200"),
                                  c(
                                      a(str("package-name"), arg)
                                  )
                              ),
                              b(str("ex-4500"),
                                  c(
                                      a(str("package-name"), arg)
                                  )
                              ),
                              b(str("ex-4300"),
                                  c(
                                      a(str("package-name"), arg)
                                  )
                              ),
                              b(str("ex-4600"),
                                  c(
                                      a(str("package-name"), arg)
                                  )
                              ),
                              b(str("qfx-3"),
                                  c(
                                      a(str("package-name"), arg)
                                  )
                              ),
                              b(str("qfx-5"),
                                  c(
                                      a(str("package-name"), arg)
                                  )
                              )
                          )
                      ),
                      c(
                        str("preprovisioned"),
                        str("auto-provisioned")
                      ),
                      b(str("id"),
                        isosysid
                      ),
                      b(str("graceful-restart"),
                          c(
                                (str("disable"))
                          )
                      ),
                      str("no-split-detection"),
                      b(str("traceoptions"),
                        juniper_virtual_chassis_traceoptions
                      ),
                      a(str("heartbeat-timeout"), arg),
                      b(str("heartbeat-address"),
                        ipaddr
                      ),
                      a(str("heartbeat-tos"), arg),
                      str("locality-bias"),
                      b(a(str("member"), arg),
                          c(
                              a(str("mastership-priority"), arg),
                              str("fabric-tree-root"),
                              b(str("role"),
                                (str("routing-engine") | str("line-card"))
                              ),
                              a(str("serial-number"), arg),
                              str("no-management-vlan"),
                              a(str("location"), arg)
                          )
                      ),
                      b(str("aliases"),
                          c(
                              b(a(str("serial-number"), arg),
                                  c(
                                      a(str("alias-name"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("mac-persistence-timer"),
                          ca(
                              str("disable")
                          )
                      ),
                      b(str("fast-failover"),
                          c(
                              str("ge"),
                              str("xe"),
                              str("et"),
                              b(str("vcp"),
                                  c(
                                      str("disable")
                                  )
                              )
                          )
                      ),
                      b(str("vc-port"),
                          c(
                              b(str("lag-hash"),
                                (str("packet-based") | str("source-port-based"))
                              )
                          )
                      ),
                      c(
                        str("no-auto-conversion"),
                        str("auto-conversion")
                      ),
                      str("vcp-no-hold-time"),
                      str("vcp-snmp-statistics")
                  )
              ),
              b(str("ethernet-switching-options"),
                  juniper_ethernet_options
              ),
              b(str("vlans"),
                  c(
                        vlan_types
                  )
              ),
              b(str("openconfig-interfaces:interfaces"),
                  c(
                      b(a(str("interface"), arg),
                          c(
                              b(str("config"),
                                  c(
                                      a(str("type"), arg),
                                      a(str("mtu"), arg),
                                      a(str("name"), arg),
                                      a(str("description"), quote | arg),
                                      b(str("enabled"),
                                        (str("true") | str("false"))
                                      )
                                  )
                              ),
                              b(str("hold-time"),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("up"), arg),
                                              a(str("down"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("subinterfaces"),
                                  c(
                                      b(str("subinterface"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("index"), arg),
                                                      a(str("name"), arg),
                                                      a(str("description"), quote | arg),
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              ),
                                              b(str("openconfig-vlan:vlan"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("vlan-id"),
                                                                time_of_day
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("openconfig-if-ip:ipv4"),
                                                  c(
                                                      b(str("addresses"),
                                                          c(
                                                              b(str("address"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("ip"), arg),
                                                                              a(str("prefix-length"), arg)
                                                                          )
                                                                      ),
                                                                      b(str("vrrp"),
                                                                          c(
                                                                              b(str("vrrp-group"),
                                                                                  s(
                                                                                          arg,
                                                                                    c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("virtual-router-id"), arg),
                                                                                              b(str("virtual-address"),
                                                                                                time_of_day
                                                                                              ),
                                                                                              a(str("priority"), arg),
                                                                                              b(str("preempt"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              a(str("preempt-delay"), arg),
                                                                                              b(str("accept-mode"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              a(str("advertisement-interval"), arg)
                                                                                          )
                                                                                      ),
                                                                                      b(str("interface-tracking"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("track-interface"), arg),
                                                                                                      a(str("priority-decrement"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                    )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("neighbors"),
                                                          c(
                                                              b(str("neighbor"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("ip"), arg),
                                                                              a(str("link-layer-address"), arg)
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("unnumbered"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("enabled"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("interface-ref"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("interface"), arg),
                                                                              a(str("subinterface"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("config"),
                                                          c(
                                                              b(str("enabled"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("mtu"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("openconfig-if-ip:ipv6"),
                                                  c(
                                                      b(str("addresses"),
                                                          c(
                                                              b(str("address"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("ip"), arg),
                                                                              a(str("prefix-length"), arg)
                                                                          )
                                                                      ),
                                                                      b(str("vrrp"),
                                                                          c(
                                                                              b(str("vrrp-group"),
                                                                                  s(
                                                                                          arg,
                                                                                    c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("virtual-router-id"), arg),
                                                                                              b(str("virtual-address"),
                                                                                                time_of_day
                                                                                              ),
                                                                                              a(str("priority"), arg),
                                                                                              b(str("preempt"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              a(str("preempt-delay"), arg),
                                                                                              b(str("accept-mode"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              a(str("advertisement-interval"), arg),
                                                                                              b(str("virtual-link-local"),
                                                                                                time_of_day
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("interface-tracking"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("track-interface"), arg),
                                                                                                      a(str("priority-decrement"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                    )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("neighbors"),
                                                          c(
                                                              b(str("neighbor"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("ip"), arg),
                                                                              a(str("link-layer-address"), arg)
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("unnumbered"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("enabled"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("interface-ref"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("interface"), arg),
                                                                              a(str("subinterface"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("config"),
                                                          c(
                                                              b(str("enabled"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("mtu"), arg),
                                                              a(str("dup-addr-detect-transmits"), arg)
                                                          )
                                                      ),
                                                      b(str("openconfig-if-ip-ext:autoconf"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("create-global-addresses"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      b(str("create-temporary-addresses"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("temporary-valid-lifetime"), arg),
                                                                      a(str("temporary-preferred-lifetime"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("jnx-aug-openconfig-if-ip:router-advertisement"),
                                                          c(
                                                              b(str("state"),
                                                                  c(
                                                                      a(str("name"), arg),
                                                                      a(str("initial-adv-sent"), arg),
                                                                      a(str("adv-sent"), arg),
                                                                      a(str("adv-received"), arg),
                                                                      a(str("solicits-received"), arg),
                                                                      a(str("last-adv-time"), arg),
                                                                      a(str("last-solicit-time"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("openconfig-if-ethernet:ethernet"),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("mac-address"), arg),
                                              b(str("auto-negotiate"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("duplex-mode"),
                                                (str("FULL") | str("HALF"))
                                              ),
                                              b(str("port-speed"),
                                                (str("SPEED_UNKNOWN") | str("SPEED_100GB") | str("SPEED_50GB") | str("SPEED_40GB") | str("SPEED_25GB") | str("SPEED_10GB") | str("SPEED_1GB") | str("SPEED_100MB") | str("SPEED_10MB"))
                                              ),
                                              b(str("enable-flow-control"),
                                                (str("true") | str("false"))
                                              ),
                                              a(str("openconfig-if-aggregate:aggregate-id"), arg)
                                          )
                                      ),
                                      b(str("openconfig-vlan:switched-vlan"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("interface-mode"),
                                                        (str("ACCESS") | str("TRUNK"))
                                                      ),
                                                      b(str("native-vlan"),
                                                        time_of_day
                                                      ),
                                                      b(str("access-vlan"),
                                                        time_of_day
                                                      ),
                                                      b(str("trunk-vlans"),
                                                        time_of_day
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("openconfig-if-aggregate:aggregation"),
                                  c(
                                      b(str("config"),
                                          c(
                                              b(str("lag-type"),
                                                (str("LACP") | str("STATIC"))
                                              ),
                                              a(str("min-links"), arg)
                                          )
                                      ),
                                      b(str("openconfig-vlan:switched-vlan"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("interface-mode"),
                                                        (str("ACCESS") | str("TRUNK"))
                                                      ),
                                                      b(str("native-vlan"),
                                                        time_of_day
                                                      ),
                                                      b(str("access-vlan"),
                                                        time_of_day
                                                      ),
                                                      b(str("trunk-vlans"),
                                                        time_of_day
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("openconfig-vlan:routed-vlan"),
                                  c(
                                      b(str("config"),
                                          c(
                                              b(str("vlan"),
                                                time_of_day
                                              )
                                          )
                                      ),
                                      b(str("openconfig-if-ip:ipv4"),
                                          c(
                                              b(str("addresses"),
                                                  c(
                                                      b(str("address"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("ip"), arg),
                                                                      a(str("prefix-length"), arg)
                                                                  )
                                                              ),
                                                              b(str("vrrp"),
                                                                  c(
                                                                      b(str("vrrp-group"),
                                                                          s(
                                                                                  arg,
                                                                            c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("virtual-router-id"), arg),
                                                                                      b(str("virtual-address"),
                                                                                        time_of_day
                                                                                      ),
                                                                                      a(str("priority"), arg),
                                                                                      b(str("preempt"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("preempt-delay"), arg),
                                                                                      b(str("accept-mode"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("advertisement-interval"), arg)
                                                                                  )
                                                                              ),
                                                                              b(str("interface-tracking"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("track-interface"), arg),
                                                                                              a(str("priority-decrement"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                            )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("neighbors"),
                                                  c(
                                                      b(str("neighbor"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("ip"), arg),
                                                                      a(str("link-layer-address"), arg)
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("unnumbered"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("enabled"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("interface-ref"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("interface"), arg),
                                                                      a(str("subinterface"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("config"),
                                                  c(
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      a(str("mtu"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("openconfig-if-ip:ipv6"),
                                          c(
                                              b(str("addresses"),
                                                  c(
                                                      b(str("address"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("ip"), arg),
                                                                      a(str("prefix-length"), arg)
                                                                  )
                                                              ),
                                                              b(str("vrrp"),
                                                                  c(
                                                                      b(str("vrrp-group"),
                                                                          s(
                                                                                  arg,
                                                                            c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("virtual-router-id"), arg),
                                                                                      b(str("virtual-address"),
                                                                                        time_of_day
                                                                                      ),
                                                                                      a(str("priority"), arg),
                                                                                      b(str("preempt"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("preempt-delay"), arg),
                                                                                      b(str("accept-mode"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("advertisement-interval"), arg),
                                                                                      b(str("virtual-link-local"),
                                                                                        time_of_day
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("interface-tracking"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("track-interface"), arg),
                                                                                              a(str("priority-decrement"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                            )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("neighbors"),
                                                  c(
                                                      b(str("neighbor"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("ip"), arg),
                                                                      a(str("link-layer-address"), arg)
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("unnumbered"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("enabled"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("interface-ref"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("interface"), arg),
                                                                      a(str("subinterface"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("config"),
                                                  c(
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      a(str("mtu"), arg),
                                                      a(str("dup-addr-detect-transmits"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-network-instance:network-instances"),
                  c(
                      b(a(str("network-instance"), arg),
                          c(
                              b(str("fdb"),
                                  c(
                                      b(str("config"),
                                          c(
                                              b(str("mac-learning"),
                                                (str("true") | str("false"))
                                              ),
                                              a(str("mac-aging-time"), arg),
                                              a(str("maximum-entries"), arg)
                                          )
                                      ),
                                      b(str("mac-table"),
                                          c(
                                              b(str("entries"),
                                                  c(
                                                      b(str("entry"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("mac-address"), arg),
                                                                      a(str("vlan"), arg)
                                                                  )
                                                              ),
                                                              b(str("interface"),
                                                                  c(
                                                                      b(str("interface-ref"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("interface"), arg),
                                                                                      a(str("subinterface"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("config"),
                                  c(
                                      a(str("name"), arg),
                                      b(str("type"),
                                        (str("L2L3") | str("L2P2P") | str("L2VSI") | str("L3VRF") | str("DEFAULT_INSTANCE"))
                                      ),
                                      b(str("enabled"),
                                        (str("true") | str("false"))
                                      ),
                                      a(str("description"), quote | arg),
                                      a(str("router-id"), arg),
                                      b(str("route-distinguisher"),
                                        time_of_day
                                      ),
                                      b(str("enabled-address-families"),
                                        (str("L2_ETHERNET") | str("MPLS") | str("IPV6") | str("IPV4"))
                                      ),
                                      a(str("mtu"), arg)
                                  )
                              ),
                              b(str("encapsulation"),
                                  c(
                                      b(str("config"),
                                          c(
                                              b(str("encapsulation-type"),
                                                (str("VXLAN") | str("MPLS"))
                                              ),
                                              b(str("label-allocation-mode"),
                                                (str("INSTANCE_LABEL") | str("PER_NEXTHOP") | str("PER_PREFIX"))
                                              ),
                                              b(str("control-word"),
                                                (str("true") | str("false"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("inter-instance-policies"),
                                  c(
                                      b(str("apply-policy"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("import-policy"), arg),
                                                      b(str("default-import-policy"),
                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                      ),
                                                      a(str("export-policy"), arg),
                                                      b(str("default-export-policy"),
                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("table-connections"),
                                  c(
                                      b(str("table-connection"),
                                          s(
                                                  arg,
                                                  arg,
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("src-protocol"), arg),
                                                      a(str("address-family"), arg),
                                                      a(str("dst-protocol"), arg),
                                                      a(str("import-policy"), arg),
                                                      b(str("default-import-policy"),
                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("interfaces"),
                                  c(
                                      b(str("interface"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("id"), arg),
                                                      a(str("interface"), arg),
                                                      a(str("subinterface"), arg),
                                                      b(str("associated-address-families"),
                                                        (str("L2_ETHERNET") | str("MPLS") | str("IPV6") | str("IPV4"))
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("tables"),
                                  c(
                                      b(str("table"),
                                          s(
                                                  arg,
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("protocol"), arg),
                                                      b(str("address-family"),
                                                        (str("L2_ETHERNET") | str("MPLS") | str("IPV6") | str("IPV4"))
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("connection-points"),
                                  c(
                                      b(str("connection-point"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("connection-point-id"), arg)
                                                  )
                                              ),
                                              b(str("endpoints"),
                                                  c(
                                                      b(str("endpoint"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("endpoint-id"), arg),
                                                                      a(str("precedence"), arg),
                                                                      b(str("type"),
                                                                        (str("REMOTE") | str("LOCAL"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("local"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("interface"), arg),
                                                                              a(str("subinterface"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("remote"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("remote-system"),
                                                                                time_of_day
                                                                              ),
                                                                              a(str("virtual-circuit-identifier"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("mpls"),
                                  c(
                                      b(str("global"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("null-label"),
                                                        (str("IMPLICIT") | str("EXPLICIT"))
                                                      )
                                                  )
                                              ),
                                              b(str("interface-attributes"),
                                                  c(
                                                      b(str("interface"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("interface-id"), arg),
                                                                      b(str("mpls-enabled"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("interface-ref"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("interface"), arg),
                                                                              a(str("subinterface"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("reserved-label-blocks"),
                                                  c(
                                                      b(str("reserved-label-block"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("local-id"), arg),
                                                                      b(str("lower-bound"),
                                                                        time_of_day
                                                                      ),
                                                                      b(str("upper-bound"),
                                                                        time_of_day
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("te-global-attributes"),
                                          c(
                                              b(str("srlgs"),
                                                  c(
                                                      b(a(str("srlg"), arg),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("name"), arg),
                                                                      a(str("value"), arg),
                                                                      a(str("cost"), arg),
                                                                      b(str("flooding-type"),
                                                                        (str("FLOODED_SRLG") | str("STATIC_SRLG"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("static-srlg-members"),
                                                                  c(
                                                                      b(str("members-list"),
                                                                          s(
                                                                                  arg,
                                                                            c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("from-address"),
                                                                                        time_of_day
                                                                                      ),
                                                                                      b(str("to-address"),
                                                                                        time_of_day
                                                                                      )
                                                                                  )
                                                                              )
                                                                            )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("mpls-admin-groups"),
                                                  c(
                                                      b(str("admin-group"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("admin-group-name"), arg),
                                                                      a(str("bit-position"), arg)
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("te-lsp-timers"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("install-delay"), arg),
                                                              a(str("cleanup-delay"), arg),
                                                              a(str("reoptimize-timer"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("te-interface-attributes"),
                                          c(
                                              b(str("interface"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("interface-id"), arg),
                                                              a(str("te-metric"), arg),
                                                              a(str("srlg-membership"), arg),
                                                              a(str("admin-group"), arg)
                                                          )
                                                      ),
                                                      b(str("interface-ref"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("interface"), arg),
                                                                      a(str("subinterface"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("igp-flooding-bandwidth"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("threshold-type"),
                                                                        (str("DELTA") | str("THRESHOLD_CROSSED"))
                                                                      ),
                                                                      a(str("delta-percentage"), arg),
                                                                      b(str("threshold-specification"),
                                                                        (str("MIRRORED_UP_DOWN") | str("SEPARATE_UP_DOWN"))
                                                                      ),
                                                                      a(str("up-thresholds"), arg),
                                                                      a(str("down-thresholds"), arg),
                                                                      a(str("up-down-thresholds"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("jnx-aug-openconfig-ni-mpls:bandwidth-measurement"),
                                                          c(
                                                              b(str("state"),
                                                                  c(
                                                                      a(str("last-calculated-sr-utilisation"), arg),
                                                                      a(str("last-sample-measured-sr-util"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("signaling-protocols"),
                                          c(
                                              b(str("rsvp-te"),
                                                  c(
                                                      str("sessions"),
                                                      str("neighbors"),
                                                      b(str("global"),
                                                          c(
                                                              b(str("graceful-restart"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enable"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("restart-time"), arg),
                                                                              a(str("recovery-time"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("soft-preemption"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enable"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("soft-preemption-timeout"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("hellos"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("hello-interval"), arg),
                                                                              b(str("refresh-reduction"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("interface-attributes"),
                                                          c(
                                                              b(str("interface"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("interface-id"), arg)
                                                                          )
                                                                      ),
                                                                      b(str("interface-ref"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("interface"), arg),
                                                                                      a(str("subinterface"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      str("bandwidth-reservations"),
                                                                      b(str("hellos"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("hello-interval"), arg),
                                                                                      b(str("refresh-reduction"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("authentication"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enable"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("authentication-key"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("subscription"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("subscription"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("protection"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("link-protection-style-requested"),
                                                                                        (str("LINK_NODE_PROTECTION_REQUESTED") | str("LINK_PROTECTION_REQUIRED") | str("UNPROTECTED"))
                                                                                      ),
                                                                                      a(str("bypass-optimize-interval"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              str("ldp")
                                          )
                                      ),
                                      b(str("lsps"),
                                          c(
                                              b(str("constrained-path"),
                                                  c(
                                                      b(str("named-explicit-paths"),
                                                          c(
                                                              b(a(str("named-explicit-path"), arg),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("name"), arg),
                                                                              b(str("sid-selection-mode"),
                                                                                (str("ADJ_SID_ONLY") | str("MIXED_MODE"))
                                                                              ),
                                                                              b(str("sid-protection-required"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("explicit-route-objects"),
                                                                          c(
                                                                              b(str("explicit-route-object"),
                                                                                  s(
                                                                                          arg,
                                                                                    c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("address"),
                                                                                                time_of_day
                                                                                              ),
                                                                                              b(str("hop-type"),
                                                                                                (str("LOOSE") | str("STRICT"))
                                                                                              ),
                                                                                              a(str("index"), arg)
                                                                                          )
                                                                                      )
                                                                                    )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("tunnels"),
                                                          c(
                                                              b(a(str("tunnel"), arg),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("name"), arg),
                                                                              b(str("type"),
                                                                                (str("P2MP") | str("P2P"))
                                                                              ),
                                                                              b(str("signaling-protocol"),
                                                                                (str("PATH_SETUP_LDP") | str("PATH_SETUP_SR") | str("PATH_SETUP_RSVP"))
                                                                              ),
                                                                              a(str("description"), quote | arg),
                                                                              b(str("admin-status"),
                                                                                (str("ADMIN_UP") | str("ADMIN_DOWN"))
                                                                              ),
                                                                              a(str("preference"), arg),
                                                                              b(str("metric-type"),
                                                                                (str("LSP_METRIC_INHERITED") | str("LSP_METRIC_ABSOLUTE") | str("LSP_METRIC_RELATIVE"))
                                                                              ),
                                                                              a(str("metric"), arg),
                                                                              b(str("shortcut-eligible"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("protection-style-requested"),
                                                                                (str("LINK_NODE_PROTECTION_REQUESTED") | str("LINK_PROTECTION_REQUIRED") | str("UNPROTECTED"))
                                                                              ),
                                                                              a(str("reoptimize-timer"), arg),
                                                                              b(str("source"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("soft-preemption"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("setup-priority"), arg),
                                                                              a(str("hold-priority"), arg)
                                                                          )
                                                                      ),
                                                                      b(str("bandwidth"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("specification-type"),
                                                                                        (str("SPECIFIED") | str("AUTO"))
                                                                                      ),
                                                                                      a(str("set-bandwidth"), arg)
                                                                                  )
                                                                              ),
                                                                              b(str("auto-bandwidth"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("enabled"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              a(str("min-bw"), arg),
                                                                                              a(str("max-bw"), arg),
                                                                                              a(str("adjust-interval"), arg),
                                                                                              a(str("adjust-threshold"), arg)
                                                                                          )
                                                                                      ),
                                                                                      b(str("overflow"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("enabled"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("overflow-threshold"), arg),
                                                                                                      a(str("trigger-event-count"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("underflow"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("enabled"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("underflow-threshold"), arg),
                                                                                                      a(str("trigger-event-count"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("p2p-tunnel-attributes"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("destination"),
                                                                                        time_of_day
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("p2p-primary-path"),
                                                                                  c(
                                                                                      b(a(str("p2p-primary-path"), arg),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("name"), arg),
                                                                                                      b(str("path-computation-method"),
                                                                                                        (str("EXPLICITLY_DEFINED") | str("EXTERNALLY_QUERIED") | str("LOCALLY_COMPUTED"))
                                                                                                      ),
                                                                                                      b(str("use-cspf"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      b(str("cspf-tiebreaker"),
                                                                                                        (str("RANDOM") | str("LEAST_FILL") | str("MOST_FILL"))
                                                                                                      ),
                                                                                                      b(str("path-computation-server"),
                                                                                                        time_of_day
                                                                                                      ),
                                                                                                      a(str("explicit-path-name"), arg),
                                                                                                      a(str("preference"), arg),
                                                                                                      a(str("setup-priority"), arg),
                                                                                                      a(str("hold-priority"), arg),
                                                                                                      a(str("retry-timer"), arg)
                                                                                                  )
                                                                                              ),
                                                                                              b(str("candidate-secondary-paths"),
                                                                                                  c(
                                                                                                      b(str("candidate-secondary-path"),
                                                                                                          s(
                                                                                                                  arg,
                                                                                                            c(
                                                                                                              b(str("config"),
                                                                                                                  c(
                                                                                                                      a(str("secondary-path"), arg),
                                                                                                                      a(str("priority"), arg)
                                                                                                                  )
                                                                                                              )
                                                                                                            )
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("admin-groups"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("exclude-group"), arg),
                                                                                                              a(str("include-all-group"), arg),
                                                                                                              a(str("include-any-group"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("jnx-aug-openconfig-ni-mpls:lsp-instances"),
                                                                                                  s(
                                                                                                          arg,
                                                                                                    c(
                                                                                                      b(str("state"),
                                                                                                          c(
                                                                                                              a(str("local-index"), arg),
                                                                                                              a(str("notify-status"), arg),
                                                                                                              a(str("metric"), arg),
                                                                                                              a(str("bandwidth"), arg),
                                                                                                              a(str("max-avg-bandwidth"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                    )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("p2p-secondary-paths"),
                                                                                  c(
                                                                                      b(a(str("p2p-secondary-path"), arg),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("name"), arg),
                                                                                                      b(str("path-computation-method"),
                                                                                                        (str("EXPLICITLY_DEFINED") | str("EXTERNALLY_QUERIED") | str("LOCALLY_COMPUTED"))
                                                                                                      ),
                                                                                                      b(str("use-cspf"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      b(str("cspf-tiebreaker"),
                                                                                                        (str("RANDOM") | str("LEAST_FILL") | str("MOST_FILL"))
                                                                                                      ),
                                                                                                      b(str("path-computation-server"),
                                                                                                        time_of_day
                                                                                                      ),
                                                                                                      a(str("explicit-path-name"), arg),
                                                                                                      a(str("preference"), arg),
                                                                                                      a(str("setup-priority"), arg),
                                                                                                      a(str("hold-priority"), arg),
                                                                                                      a(str("retry-timer"), arg)
                                                                                                  )
                                                                                              ),
                                                                                              b(str("admin-groups"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("exclude-group"), arg),
                                                                                                              a(str("include-all-group"), arg),
                                                                                                              a(str("include-any-group"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("jnx-aug-openconfig-ni-mpls:container-tunnels"),
                                                          c(
                                                              b(a(str("container-tunnel"), arg),
                                                                  c(
                                                                      b(str("state"),
                                                                          c(
                                                                              a(str("name"), arg),
                                                                              b(str("oper-state"),
                                                                                (str("CONTAINER_TUNNEL_UP") | str("CONTAINER_TUNNEL_DOWN"))
                                                                              ),
                                                                              a(str("normalization-status"), arg),
                                                                              a(str("member-count"), arg),
                                                                              a(str("minimum-lsp-count"), arg),
                                                                              a(str("maximum-lsp-count"), arg),
                                                                              a(str("normalize-timer"), arg),
                                                                              a(str("normalize-threshold"), arg),
                                                                              a(str("aggregate-bandwidth"), arg),
                                                                              a(str("sampled-aggregate-bandwidth"), arg),
                                                                              a(str("max-signalling-bandwidth"), arg),
                                                                              a(str("min-signalling-bandwidth"), arg),
                                                                              a(str("splitting-bandwidth"), arg),
                                                                              a(str("merging-bandwidth"), arg),
                                                                              a(str("time-to-normalize"), arg),
                                                                              b(str("incremental-normalization"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("failover-normalization"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("sampling"),
                                                                                  c(
                                                                                      a(str("sampling-outlier-cutoff"), arg),
                                                                                      b(str("sampling-mode"),
                                                                                        (str("SAMPLE_MODE_NONE") | str("SAMPLE_MODE_AVERAGE_AGGREGATE") | str("SAMPLE_MODE_MAX_AGGREGATE") | str("SAMPLE_MODE_PERCENTILE_BASED"))
                                                                                      ),
                                                                                      a(str("sampling-percentile"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("unconstrained-path"),
                                                  c(
                                                      b(str("path-setup-protocol"),
                                                          c(
                                                              str("ldp")
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("static-lsps"),
                                                  c(
                                                      b(a(str("static-lsp"), arg),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("name"), arg)
                                                                  )
                                                              ),
                                                              b(str("ingress"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("next-hop"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("incoming-label"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("push-label"),
                                                                                time_of_day
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("transit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("next-hop"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("incoming-label"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("push-label"),
                                                                                time_of_day
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("egress"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("next-hop"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("incoming-label"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("push-label"),
                                                                                time_of_day
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("vlans"),
                                  c(
                                      b(str("vlan"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("vlan-id"), arg),
                                                      a(str("name"), arg),
                                                      b(str("status"),
                                                        (str("ACTIVE") | str("SUSPENDED"))
                                                      ),
                                                      b(str("tpid"),
                                                        (str("TPID_0X9200") | str("TPID_0x9100") | str("TPID_0x8A88") | str("TPID_0x8100"))
                                                      )
                                                  )
                                              ),
                                              str("members")
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("protocols"),
                                  c(
                                      b(a(str("protocol"), arg),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      b(str("identifier"),
                                                        (str("IGMP") | str("PIM") | str("LOCAL_AGGREGATE") | str("DIRECTLY_CONNECTED") | str("STATIC") | str("OSPF3") | str("OSPF") | str("ISIS") | str("BGP"))
                                                      ),
                                                      a(str("name"), arg),
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      a(str("default-metric"), arg)
                                                  )
                                              ),
                                              b(str("static-routes"),
                                                  c(
                                                      b(str("static"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("prefix"),
                                                                        time_of_day
                                                                      ),
                                                                      b(str("set-tag"),
                                                                        time_of_day
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("next-hops"),
                                                                  c(
                                                                      b(str("next-hop"),
                                                                          s(
                                                                                  arg,
                                                                            c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("index"), arg),
                                                                                      a(str("next-hop"), arg),
                                                                                      a(str("metric"), arg),
                                                                                      b(str("recurse"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("interface-ref"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("interface"), arg),
                                                                                              a(str("subinterface"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                            )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("local-aggregates"),
                                                  c(
                                                      b(str("aggregate"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("prefix"),
                                                                        time_of_day
                                                                      ),
                                                                      b(str("discard"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      b(str("set-tag"),
                                                                        time_of_day
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("bgp"),
                                                  c(
                                                      b(str("global"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("as"), arg),
                                                                      a(str("router-id"), arg)
                                                                  )
                                                              ),
                                                              b(str("default-route-distance"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("external-route-distance"), arg),
                                                                              a(str("internal-route-distance"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("confederation"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("identifier"), arg),
                                                                              a(str("member-as"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("graceful-restart"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enabled"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("restart-time"), arg),
                                                                              a(str("stale-routes-time"), arg),
                                                                              b(str("helper-only"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("use-multiple-paths"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enabled"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("ebgp"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("allow-multiple-as"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("maximum-paths"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("ibgp"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("maximum-paths"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("route-selection-options"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("always-compare-med"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("ignore-as-path-length"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("external-compare-router-id"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("advertise-inactive-routes"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("enable-aigp"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("ignore-next-hop-igp-metric"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("afi-safis"),
                                                                  c(
                                                                      b(str("afi-safi"),
                                                                          s(
                                                                                  arg,
                                                                            c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("afi-safi-name"),
                                                                                        (str("L2VPN_EVPN") | str("L2VPN_VPLS") | str("L3VPN_IPV6_MULTICAST") | str("L3VPN_IPV4_MULTICAST") | str("L3VPN_IPV6_UNICAST") | str("L3VPN_IPV4_UNICAST") | str("IPV6_LABELED_UNICAST") | str("IPV4_LABELED_UNICAST") | str("IPV6_UNICAST") | str("IPV4_UNICAST") | str("IPV4_MULTICAST") | str("IPV6_MULTICAST"))
                                                                                      ),
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("graceful-restart"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("enabled"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("route-selection-options"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("always-compare-med"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              b(str("ignore-as-path-length"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              b(str("external-compare-router-id"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              b(str("advertise-inactive-routes"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              b(str("enable-aigp"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              b(str("ignore-next-hop-igp-metric"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("use-multiple-paths"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("enabled"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ebgp"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("allow-multiple-as"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("maximum-paths"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ibgp"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("maximum-paths"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("add-paths"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("receive"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              b(str("send"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              a(str("send-max"), arg),
                                                                                              a(str("eligible-prefix-policy"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("ipv4-unicast"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("send-default-route"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("ipv6-unicast"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("send-default-route"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("ipv4-labeled-unicast"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("ipv6-labeled-unicast"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("l3vpn-ipv4-unicast"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("l3vpn-ipv6-unicast"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("l3vpn-ipv4-multicast"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("l3vpn-ipv6-multicast"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("l2vpn-vpls"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("l2vpn-evpn"),
                                                                                  c(
                                                                                      b(str("prefix-limit"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("max-prefixes"), arg),
                                                                                                      b(str("prevent-teardown"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                                                      a(str("restart-timer"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                            )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("dynamic-neighbor-prefixes"),
                                                                  c(
                                                                      b(str("dynamic-neighbor-prefix"),
                                                                          s(
                                                                                  arg,
                                                                            c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("prefix"),
                                                                                        time_of_day
                                                                                      ),
                                                                                      a(str("peer-group"), arg)
                                                                                  )
                                                                              )
                                                                            )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("neighbors"),
                                                          c(
                                                              b(str("neighbor"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("peer-group"), arg),
                                                                              b(str("neighbor-address"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("enabled"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("peer-as"), arg),
                                                                              a(str("local-as"), arg),
                                                                              b(str("peer-type"),
                                                                                (str("INTERNAL") | str("EXTERNAL"))
                                                                              ),
                                                                              a(str("auth-password"), arg),
                                                                              b(str("remove-private-as"),
                                                                                (str("PRIVATE_AS_REPLACE_ALL") | str("PRIVATE_AS_REMOVE_ALL"))
                                                                              ),
                                                                              b(str("route-flap-damping"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("send-community"),
                                                                                (str("STANDARD") | str("EXTENDED") | str("BOTH") | str("NONE"))
                                                                              ),
                                                                              a(str("description"), quote | arg)
                                                                          )
                                                                      ),
                                                                      b(str("timers"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("connect-retry"), arg),
                                                                                      a(str("hold-time"), arg),
                                                                                      a(str("keepalive-interval"), arg),
                                                                                      a(str("minimum-advertisement-interval"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("transport"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("tcp-mss"), arg),
                                                                                      b(str("mtu-discovery"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("passive-mode"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("local-address"),
                                                                                        time_of_day
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("error-handling"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("treat-as-withdraw"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("graceful-restart"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("restart-time"), arg),
                                                                                      a(str("stale-routes-time"), arg),
                                                                                      b(str("helper-only"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("logging-options"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("log-neighbor-state-changes"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("ebgp-multihop"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("multihop-ttl"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("route-reflector"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("route-reflector-cluster-id"),
                                                                                        time_of_day
                                                                                      ),
                                                                                      b(str("route-reflector-client"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("as-path-options"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("allow-own-as"), arg),
                                                                                      b(str("replace-peer-as"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("disable-peer-as-filter"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("use-multiple-paths"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("ebgp"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("allow-multiple-as"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("apply-policy"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("import-policy"), arg),
                                                                                      b(str("default-import-policy"),
                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                      ),
                                                                                      a(str("export-policy"), arg),
                                                                                      b(str("default-export-policy"),
                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("afi-safis"),
                                                                          c(
                                                                              b(str("afi-safi"),
                                                                                  s(
                                                                                          arg,
                                                                                    c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("afi-safi-name"),
                                                                                                (str("L2VPN_EVPN") | str("L2VPN_VPLS") | str("L3VPN_IPV6_MULTICAST") | str("L3VPN_IPV4_MULTICAST") | str("L3VPN_IPV6_UNICAST") | str("L3VPN_IPV4_UNICAST") | str("IPV6_LABELED_UNICAST") | str("IPV4_LABELED_UNICAST") | str("IPV6_UNICAST") | str("IPV4_UNICAST") | str("IPV4_MULTICAST") | str("IPV6_MULTICAST"))
                                                                                              ),
                                                                                              b(str("enabled"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("graceful-restart"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("enabled"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("add-paths"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("receive"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      b(str("send"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("send-max"), arg),
                                                                                                      a(str("eligible-prefix-policy"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("apply-policy"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("import-policy"), arg),
                                                                                                      b(str("default-import-policy"),
                                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                                      ),
                                                                                                      a(str("export-policy"), arg),
                                                                                                      b(str("default-export-policy"),
                                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ipv4-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("send-default-route"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ipv6-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("send-default-route"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ipv4-labeled-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ipv6-labeled-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l3vpn-ipv4-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l3vpn-ipv6-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l3vpn-ipv4-multicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l3vpn-ipv6-multicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l2vpn-vpls"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l2vpn-evpn"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("use-multiple-paths"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("enabled"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("ebgp"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              b(str("allow-multiple-as"),
                                                                                                                (str("true") | str("false"))
                                                                                                              )
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                    )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      a(str("jnx-aug-openconfig-ni:snmp-peer-index"), arg)
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("peer-groups"),
                                                          c(
                                                              b(str("peer-group"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("peer-group-name"), arg),
                                                                              a(str("peer-as"), arg),
                                                                              a(str("local-as"), arg),
                                                                              b(str("peer-type"),
                                                                                (str("INTERNAL") | str("EXTERNAL"))
                                                                              ),
                                                                              a(str("auth-password"), arg),
                                                                              b(str("remove-private-as"),
                                                                                (str("PRIVATE_AS_REPLACE_ALL") | str("PRIVATE_AS_REMOVE_ALL"))
                                                                              ),
                                                                              b(str("route-flap-damping"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("send-community"),
                                                                                (str("STANDARD") | str("EXTENDED") | str("BOTH") | str("NONE"))
                                                                              ),
                                                                              a(str("description"), quote | arg)
                                                                          )
                                                                      ),
                                                                      b(str("timers"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("connect-retry"), arg),
                                                                                      a(str("hold-time"), arg),
                                                                                      a(str("keepalive-interval"), arg),
                                                                                      a(str("minimum-advertisement-interval"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("transport"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("tcp-mss"), arg),
                                                                                      b(str("mtu-discovery"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("passive-mode"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("local-address"),
                                                                                        time_of_day
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("error-handling"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("treat-as-withdraw"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("graceful-restart"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("restart-time"), arg),
                                                                                      a(str("stale-routes-time"), arg),
                                                                                      b(str("helper-only"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("logging-options"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("log-neighbor-state-changes"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("ebgp-multihop"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("multihop-ttl"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("route-reflector"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("route-reflector-cluster-id"),
                                                                                        time_of_day
                                                                                      ),
                                                                                      b(str("route-reflector-client"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("as-path-options"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("allow-own-as"), arg),
                                                                                      b(str("replace-peer-as"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("disable-peer-as-filter"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("use-multiple-paths"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("ebgp"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("allow-multiple-as"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              a(str("maximum-paths"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("ibgp"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("maximum-paths"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("apply-policy"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("import-policy"), arg),
                                                                                      b(str("default-import-policy"),
                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                      ),
                                                                                      a(str("export-policy"), arg),
                                                                                      b(str("default-export-policy"),
                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("afi-safis"),
                                                                          c(
                                                                              b(str("afi-safi"),
                                                                                  s(
                                                                                          arg,
                                                                                    c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("afi-safi-name"),
                                                                                                (str("L2VPN_EVPN") | str("L2VPN_VPLS") | str("L3VPN_IPV6_MULTICAST") | str("L3VPN_IPV4_MULTICAST") | str("L3VPN_IPV6_UNICAST") | str("L3VPN_IPV4_UNICAST") | str("IPV6_LABELED_UNICAST") | str("IPV4_LABELED_UNICAST") | str("IPV6_UNICAST") | str("IPV4_UNICAST") | str("IPV4_MULTICAST") | str("IPV6_MULTICAST"))
                                                                                              ),
                                                                                              b(str("enabled"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("graceful-restart"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("enabled"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("add-paths"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("receive"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      b(str("send"),
                                                                                                        (str("true") | str("false"))
                                                                                                      ),
                                                                                                      a(str("send-max"), arg),
                                                                                                      a(str("eligible-prefix-policy"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("use-multiple-paths"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("enabled"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("ebgp"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              b(str("allow-multiple-as"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("maximum-paths"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("ibgp"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("maximum-paths"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("apply-policy"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("import-policy"), arg),
                                                                                                      b(str("default-import-policy"),
                                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                                      ),
                                                                                                      a(str("export-policy"), arg),
                                                                                                      b(str("default-export-policy"),
                                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ipv4-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("send-default-route"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ipv6-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("send-default-route"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ipv4-labeled-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("ipv6-labeled-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l3vpn-ipv4-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l3vpn-ipv6-unicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l3vpn-ipv4-multicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l3vpn-ipv6-multicast"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l2vpn-vpls"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("l2vpn-evpn"),
                                                                                          c(
                                                                                              b(str("prefix-limit"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("max-prefixes"), arg),
                                                                                                              b(str("prevent-teardown"),
                                                                                                                (str("true") | str("false"))
                                                                                                              ),
                                                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                                                              a(str("restart-timer"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                    )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("isis"),
                                                  c(
                                                      b(str("global"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("authentication-check"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("instance"), arg),
                                                                      a(str("net"), arg),
                                                                      a(str("maximum-area-addresses"), arg),
                                                                      b(str("level-capability"),
                                                                        (str("LEVEL_1") | str("LEVEL_2") | str("LEVEL_1_2"))
                                                                      ),
                                                                      a(str("max-ecmp-paths"), arg),
                                                                      b(str("poi-tlv"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      b(str("iid-tlv"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      b(str("fast-flooding"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("lsp-bit"),
                                                                  c(
                                                                      b(str("overload-bit"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("set-bit"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("set-bit-on-boot"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("advertise-high-metric"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("reset-triggers"),
                                                                                  c(
                                                                                      b(str("reset-trigger"),
                                                                                          s(
                                                                                                  arg,
                                                                                            c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("reset-trigger"),
                                                                                                        (str("WAIT_FOR_SYSTEM") | str("WAIT_FOR_BGP"))
                                                                                                      ),
                                                                                                      a(str("delay"), arg)
                                                                                                  )
                                                                                              )
                                                                                            )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("attached-bit"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("ignore-bit"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("suppress-bit"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("reference-bandwidth"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("reference-bandwidth"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("nsr"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enabled"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("graceful-restart"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enabled"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("helper-only"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("timers"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("lsp-lifetime-interval"), arg),
                                                                              a(str("lsp-refresh-interval"), arg)
                                                                          )
                                                                      ),
                                                                      b(str("spf"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("spf-hold-interval"), arg),
                                                                                      a(str("spf-first-interval"), arg),
                                                                                      a(str("spf-second-interval"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("lsp-generation"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("lsp-max-wait-interval"), arg),
                                                                                      a(str("lsp-first-wait-interval"), arg),
                                                                                      a(str("lsp-second-wait-interval"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("transport"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("lsp-mtu-size"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("mpls"),
                                                                  c(
                                                                      b(str("igp-ldp-sync"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("post-session-up-delay"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("igp-shortcuts"),
                                                                  c(
                                                                      b(str("afi"),
                                                                          s(
                                                                                  arg,
                                                                            c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("afi-name"),
                                                                                        (str("IPV6") | str("IPV4"))
                                                                                      ),
                                                                                      b(str("nh-type"),
                                                                                        (str("PATH_SETUP_LDP") | str("PATH_SETUP_SR") | str("PATH_SETUP_RSVP"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                            )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("afi-safi"),
                                                                  c(
                                                                      b(str("af"),
                                                                          s(
                                                                                  arg,
                                                                                  arg,
                                                                            c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("afi-name"),
                                                                                        (str("IPV6") | str("IPV4"))
                                                                                      ),
                                                                                      b(str("safi-name"),
                                                                                        (str("MULTICAST") | str("UNICAST"))
                                                                                      ),
                                                                                      a(str("metric"), arg),
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("multi-topology"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("afi-name"),
                                                                                                (str("IPV6") | str("IPV4"))
                                                                                              ),
                                                                                              b(str("safi-name"),
                                                                                                (str("MULTICAST") | str("UNICAST"))
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                            )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("inter-level-propagation-policies"),
                                                                  c(
                                                                      b(str("level1-to-level2"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("import-policy"), arg),
                                                                                      b(str("default-import-policy"),
                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("level2-to-level1"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("import-policy"), arg),
                                                                                      b(str("default-import-policy"),
                                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("levels"),
                                                          c(
                                                              b(str("level"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enabled"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("level-number"), arg),
                                                                              b(str("metric-style"),
                                                                                (str("NARROW_METRIC") | str("WIDE_METRIC"))
                                                                              ),
                                                                              b(str("authentication-check"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      ),
                                                                      str("system-level-counters"),
                                                                      b(str("traffic-engineering"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("ipv4-router-id"), arg),
                                                                                      a(str("ipv6-router-id"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("route-preference"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("external-route-preference"), arg),
                                                                                      a(str("internal-route-preference"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("authentication"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("csnp-authentication"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("psnp-authentication"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("lsp-authentication"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("key"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("auth-password"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              str("keychain")
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("interfaces"),
                                                          c(
                                                              b(str("interface"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enabled"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("interface-id"), arg),
                                                                              b(str("passive"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              b(str("hello-padding"),
                                                                                (str("STRICT") | str("LOOSE") | str("ADAPTIVE") | str("DISABLE"))
                                                                              ),
                                                                              b(str("circuit-type"),
                                                                                (str("POINT_TO_POINT") | str("BROADCAST"))
                                                                              )
                                                                          )
                                                                      ),
                                                                      str("circuit-counters"),
                                                                      b(str("authentication"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("hello-authentication"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("key"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("auth-password"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              str("keychain")
                                                                          )
                                                                      ),
                                                                      b(str("afi-safi"),
                                                                          c(
                                                                              b(str("af"),
                                                                                  s(
                                                                                          arg,
                                                                                          arg,
                                                                                    c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              b(str("afi-name"),
                                                                                                (str("IPV6") | str("IPV4"))
                                                                                              ),
                                                                                              b(str("safi-name"),
                                                                                                (str("MULTICAST") | str("UNICAST"))
                                                                                              ),
                                                                                              b(str("enabled"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      )
                                                                                    )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("levels"),
                                                                          c(
                                                                              b(str("level"),
                                                                                  s(
                                                                                          arg,
                                                                                    c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("level-number"), arg),
                                                                                              b(str("passive"),
                                                                                                (str("true") | str("false"))
                                                                                              ),
                                                                                              a(str("priority"), arg),
                                                                                              b(str("enabled"),
                                                                                                (str("true") | str("false"))
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("packet-counters"),
                                                                                          c(
                                                                                              str("lsp"),
                                                                                              str("iih"),
                                                                                              str("ish"),
                                                                                              str("esh"),
                                                                                              str("psnp"),
                                                                                              str("csnp"),
                                                                                              str("unknown")
                                                                                          )
                                                                                      ),
                                                                                      b(str("timers"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("hello-interval"), arg),
                                                                                                      a(str("hello-multiplier"), arg)
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("afi-safi"),
                                                                                          c(
                                                                                              b(str("af"),
                                                                                                  s(
                                                                                                          arg,
                                                                                                          arg,
                                                                                                    c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              b(str("afi-name"),
                                                                                                                (str("IPV6") | str("IPV4"))
                                                                                                              ),
                                                                                                              b(str("safi-name"),
                                                                                                                (str("MULTICAST") | str("UNICAST"))
                                                                                                              ),
                                                                                                              a(str("metric"), arg),
                                                                                                              b(str("enabled"),
                                                                                                                (str("true") | str("false"))
                                                                                                              )
                                                                                                          )
                                                                                                      )
                                                                                                    )
                                                                                                  )
                                                                                              )
                                                                                          )
                                                                                      ),
                                                                                      b(str("hello-authentication"),
                                                                                          c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      b(str("hello-authentication"),
                                                                                                        (str("true") | str("false"))
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              b(str("key"),
                                                                                                  c(
                                                                                                      b(str("config"),
                                                                                                          c(
                                                                                                              a(str("auth-password"), arg)
                                                                                                          )
                                                                                                      )
                                                                                                  )
                                                                                              ),
                                                                                              str("keychain")
                                                                                          )
                                                                                      )
                                                                                    )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("timers"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("csnp-interval"), arg),
                                                                                      a(str("lsp-pacing-interval"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("bfd"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("bfd-tlv"),
                                                                                        (str("true") | str("false"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("interface-ref"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("interface"), arg),
                                                                                      a(str("subinterface"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("jnx-aug-openconfig-isis:packet-counters"),
                                                                          c(
                                                                              str("lsp"),
                                                                              str("iih"),
                                                                              str("ish"),
                                                                              str("esh"),
                                                                              str("psnp"),
                                                                              str("csnp"),
                                                                              str("unknown")
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-lldp:lldp"),
                  c(
                      b(str("config"),
                          c(
                              b(str("enabled"),
                                (str("true") | str("false"))
                              ),
                              a(str("hello-timer"), arg),
                              b(str("suppress-tlv-advertisement"),
                                (str("MANAGEMENT_ADDRESS") | str("SYSTEM_CAPABILITIES") | str("SYSTEM_DESCRIPTION") | str("SYSTEM_NAME") | str("PORT_DESCRIPTION") | str("PORT_ID") | str("CHASSIS_ID"))
                              ),
                              a(str("name"), quote | arg),
                              a(str("system-description"), arg),
                              a(str("chassis-id"), arg),
                              b(str("chassis-id-type"),
                                (str("CHASSIS_COMPONENT") | str("INTERFACE_ALIAS") | str("PORT_COMPONENT") | str("MAC_ADDRESS") | str("NETWORK_ADDRESS") | str("INTERFACE_NAME") | str("LOCAL"))
                              )
                          )
                      ),
                      b(str("interfaces"),
                          c(
                              b(a(str("interface"), arg),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("name"), arg),
                                              b(str("enabled"),
                                                (str("true") | str("false"))
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-platform:components"),
                  c(
                      b(a(str("component"), arg),
                          c(
                              b(str("config"),
                                  c(
                                      a(str("name"), arg)
                                  )
                              ),
                              b(str("properties"),
                                  c(
                                      b(a(str("property"), arg),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("name"), arg),
                                                      a(str("value"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("subcomponents"),
                                  c(
                                      b(a(str("subcomponent"), arg),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("name"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("openconfig-platform-transceiver:transceiver"),
                                  c(
                                      b(str("config"),
                                          c(
                                              b(str("enabled"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("form-factor"),
                                                (str("OTHER") | str("NON_PLUGGABLE") | str("X2") | str("XFP") | str("SFP_PLUS") | str("SFP") | str("QSFP28") | str("QSFP") | str("CFP4") | str("CFP2_ACO") | str("CFP2") | str("CFP"))
                                              )
                                          )
                                      ),
                                      b(str("physical-channels"),
                                          c(
                                              b(str("channel"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("index"), arg),
                                                              a(str("description"), quote | arg),
                                                              b(str("tx-laser"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("target-output-power"), arg)
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-routing-policy:routing-policy"),
                  c(
                      b(str("defined-sets"),
                          c(
                              b(str("prefix-sets"),
                                  c(
                                      b(a(str("prefix-set"), arg),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("name"), arg),
                                                      b(str("mode"),
                                                        (str("IPV4") | str("IPV6") | str("MIXED"))
                                                      )
                                                  )
                                              ),
                                              b(str("prefixes"),
                                                  c(
                                                      b(str("prefix"),
                                                          s(
                                                                  arg,
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("ip-prefix"),
                                                                        time_of_day
                                                                      ),
                                                                      a(str("masklength-range"), arg)
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("neighbor-sets"),
                                  c(
                                      b(a(str("neighbor-set"), arg),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("name"), arg),
                                                      b(str("address"),
                                                        time_of_day
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("tag-sets"),
                                  c(
                                      b(a(str("tag-set"), arg),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("name"), arg),
                                                      b(str("tag-value"),
                                                        time_of_day
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("openconfig-bgp-policy:bgp-defined-sets"),
                                  c(
                                      b(str("community-sets"),
                                          c(
                                              b(str("community-set"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("community-set-name"), arg),
                                                              a(str("community-member"), arg)
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("ext-community-sets"),
                                          c(
                                              b(str("ext-community-set"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("ext-community-set-name"), arg),
                                                              b(str("ext-community-member"),
                                                                time_of_day
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("as-path-sets"),
                                          c(
                                              b(str("as-path-set"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("as-path-set-name"), arg),
                                                              a(str("as-path-set-member"), arg)
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("policy-definitions"),
                          c(
                              b(a(str("policy-definition"), arg),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("name"), arg)
                                          )
                                      ),
                                      b(str("statements"),
                                          c(
                                              b(a(str("statement"), arg),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("name"), arg)
                                                          )
                                                      ),
                                                      b(str("conditions"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("call-policy"), arg),
                                                                      b(str("install-protocol-eq"),
                                                                        (str("IGMP") | str("PIM") | str("LOCAL_AGGREGATE") | str("DIRECTLY_CONNECTED") | str("STATIC") | str("OSPF3") | str("OSPF") | str("ISIS") | str("BGP"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("match-interface"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("interface"), arg),
                                                                              a(str("subinterface"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("match-prefix-set"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("prefix-set"), arg),
                                                                              b(str("match-set-options"),
                                                                                (str("ANY") | str("INVERT"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("match-neighbor-set"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("neighbor-set"), arg),
                                                                              b(str("match-set-options"),
                                                                                (str("ANY") | str("INVERT"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("match-tag-set"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("tag-set"), arg),
                                                                              b(str("match-set-options"),
                                                                                (str("ANY") | str("INVERT"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("openconfig-bgp-policy:bgp-conditions"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("med-eq"), arg),
                                                                              b(str("origin-eq"),
                                                                                (str("IGP") | str("EGP") | str("INCOMPLETE"))
                                                                              ),
                                                                              b(str("next-hop-in"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("afi-safi-in"),
                                                                                (str("L2VPN_EVPN") | str("L2VPN_VPLS") | str("L3VPN_IPV6_MULTICAST") | str("L3VPN_IPV4_MULTICAST") | str("L3VPN_IPV6_UNICAST") | str("L3VPN_IPV4_UNICAST") | str("IPV6_LABELED_UNICAST") | str("IPV4_LABELED_UNICAST") | str("IPV6_UNICAST") | str("IPV4_UNICAST") | str("IPV4_MULTICAST") | str("IPV6_MULTICAST") | str("FABRIC_VPN") | str("FABRIC") | str("BRIDGE_VPN_UNICAST") | str("BRIDGE_UNICAST") | str("TE_UNICAST") | str("IPV4_MDT") | str("IPV6_MVPN") | str("IPV4_MVPN") | str("ISO_VPN_UNICAST") | str("ISO_UNICAST") | str("IPV6_VPN_FLOW") | str("IPV6_FLOW") | str("IPV4_VPN_FLOW") | str("IPV4_FLOW") | str("ROUTE_TARGET") | str("ATMVPN") | str("L2VPN_MSPW_AD"))
                                                                              ),
                                                                              a(str("local-pref-eq"), arg),
                                                                              b(str("route-type"),
                                                                                (str("INTERNAL") | str("EXTERNAL"))
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("community-count"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("operator"),
                                                                                        (str("ATTRIBUTE_LE") | str("ATTRIBUTE_GE") | str("ATTRIBUTE_EQ"))
                                                                                      ),
                                                                                      a(str("value"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("as-path-length"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("operator"),
                                                                                        (str("ATTRIBUTE_LE") | str("ATTRIBUTE_GE") | str("ATTRIBUTE_EQ"))
                                                                                      ),
                                                                                      a(str("value"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("match-community-set"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("community-set"), arg),
                                                                                      b(str("match-set-options"),
                                                                                        (str("ANY") | str("ALL") | str("INVERT"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("match-ext-community-set"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("ext-community-set"), arg),
                                                                                      b(str("match-set-options"),
                                                                                        (str("ANY") | str("ALL") | str("INVERT"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("match-as-path-set"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("as-path-set"), arg),
                                                                                      b(str("match-set-options"),
                                                                                        (str("ANY") | str("ALL") | str("INVERT"))
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("openconfig-isis-policy:isis-conditions"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("level-eq"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("actions"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("policy-result"),
                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("openconfig-bgp-policy:bgp-actions"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("set-route-origin"),
                                                                                (str("IGP") | str("EGP") | str("INCOMPLETE"))
                                                                              ),
                                                                              a(str("set-local-pref"), arg),
                                                                              b(str("set-next-hop"),
                                                                                time_of_day
                                                                              ),
                                                                              a(str("set-med"), arg)
                                                                          )
                                                                      ),
                                                                      b(str("set-as-path-prepend"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("repeat-n"), arg),
                                                                                      a(str("asn"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("set-community"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("method"),
                                                                                        (str("INLINE") | str("REFERENCE"))
                                                                                      ),
                                                                                      b(str("options"),
                                                                                        (str("ADD") | str("REMOVE") | str("REPLACE"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("inline"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("communities"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("reference"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("community-set-ref"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("set-ext-community"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("method"),
                                                                                        (str("INLINE") | str("REFERENCE"))
                                                                                      ),
                                                                                      b(str("options"),
                                                                                        (str("ADD") | str("REMOVE") | str("REPLACE"))
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("inline"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("communities"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("reference"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("ext-community-set-ref"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("openconfig-isis-policy:isis-actions"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("set-level"), arg),
                                                                              a(str("set-metric-type"), arg),
                                                                              a(str("set-metric"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-telemetry:telemetry-system"),
                  c(
                      b(str("sensor-groups"),
                          c(
                              b(str("sensor-group"),
                                  s(
                                          arg,
                                    c(
                                      b(str("config"),
                                          c(
                                              a(str("sensor-group-id"), arg)
                                          )
                                      ),
                                      b(str("sensor-paths"),
                                          c(
                                              b(str("sensor-path"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("path"), arg),
                                                              a(str("exclude-filter"), arg)
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                    )
                                  )
                              )
                          )
                      ),
                      b(str("destination-groups"),
                          c(
                              b(str("destination-group"),
                                  s(
                                          arg,
                                    c(
                                      b(str("config"),
                                          c(
                                              a(str("group-id"), arg)
                                          )
                                      ),
                                      b(str("destinations"),
                                          c(
                                              b(str("destination"),
                                                  s(
                                                          arg,
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("destination-address"),
                                                                time_of_day
                                                              ),
                                                              a(str("destination-port"), arg),
                                                              b(str("destination-protocol"),
                                                                (str("TCP") | str("UDP"))
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                    )
                                  )
                              )
                          )
                      ),
                      b(str("subscriptions"),
                          c(
                              b(str("persistent"),
                                  c(
                                      b(str("subscription"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("subscription-id"), arg),
                                                      b(str("local-source-address"),
                                                        time_of_day
                                                      ),
                                                      a(str("originated-qos-marking"), arg)
                                                  )
                                              ),
                                              b(str("sensor-profiles"),
                                                  c(
                                                      b(str("sensor-profile"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("sensor-group"), arg),
                                                                      a(str("sample-interval"), arg),
                                                                      a(str("heartbeat-interval"), arg),
                                                                      b(str("suppress-redundant"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("destination-groups"),
                                                  c(
                                                      b(str("destination-group"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("group-id"), arg)
                                                                  )
                                                              ),
                                                              b(str("state"),
                                                                  c(
                                                                      a(str("group-id"), arg)
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              str("dynamic")
                          )
                      )
                  )
              ),
              b(str("openconfig-vlan:vlans"),
                  c(
                      b(str("vlan"),
                          s(
                                  arg,
                            c(
                              b(str("config"),
                                  c(
                                      a(str("vlan-id"), arg),
                                      a(str("name"), arg),
                                      b(str("status"),
                                        (str("ACTIVE") | str("SUSPENDED"))
                                      ),
                                      b(str("tpid"),
                                        (str("TPID_0X9200") | str("TPID_0x9100") | str("TPID_0x8A88") | str("TPID_0x8100"))
                                      )
                                  )
                              ),
                              str("members")
                            )
                          )
                      )
                  )
              ),
              b(str("ietf-interfaces:interfaces"),
                  c(
                      b(a(str("interface"), arg),
                          c(
                              a(str("description"), quote | arg),
                              b(str("type"),
                                (str("iana-interface-type"))
                              ),
                              b(str("enabled"),
                                (str("true") | str("false"))
                              ),
                              b(str("link-up-down-trap-enable"),
                                (str("enabled") | str("disabled"))
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-system:system"),
                  c(
                      b(str("config"),
                          c(
                              a(str("hostname"), arg),
                              a(str("domain-name"), arg),
                              a(str("login-banner"), arg),
                              a(str("motd-banner"), arg)
                          )
                      ),
                      b(str("clock"),
                          c(
                              b(str("config"),
                                  c(
                                      a(str("timezone-name"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("dns"),
                          c(
                              b(str("config"),
                                  c(
                                      a(str("search"), arg)
                                  )
                              ),
                              b(str("servers"),
                                  c(
                                      b(str("server"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      b(str("address"),
                                                        time_of_day
                                                      ),
                                                      a(str("port"), arg)
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("host-entries"),
                                  c(
                                      b(str("host-entry"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("hostname"), arg),
                                                      a(str("alias"), arg),
                                                      a(str("ipv4-address"), arg),
                                                      a(str("ipv6-address"), arg)
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("ntp"),
                          c(
                              b(str("config"),
                                  c(
                                      b(str("enabled"),
                                        (str("true") | str("false"))
                                      ),
                                      b(str("ntp-source-address"),
                                        time_of_day
                                      ),
                                      b(str("enable-ntp-auth"),
                                        (str("true") | str("false"))
                                      )
                                  )
                              ),
                              b(str("ntp-keys"),
                                  c(
                                      b(str("ntp-key"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("key-id"), arg),
                                                      b(str("key-type"),
                                                        (str("NTP_AUTH_MD5"))
                                                      ),
                                                      a(str("key-value"), arg)
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("servers"),
                                  c(
                                      b(str("server"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      b(str("address"),
                                                        time_of_day
                                                      ),
                                                      a(str("port"), arg),
                                                      a(str("version"), arg),
                                                      b(str("association-type"),
                                                        (str("SERVER") | str("PEER") | str("POOL"))
                                                      ),
                                                      b(str("iburst"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      b(str("prefer"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("grpc-server"),
                          c(
                              b(str("config"),
                                  c(
                                      b(str("enable"),
                                        (str("true") | str("false"))
                                      ),
                                      a(str("port"), arg),
                                      b(str("transport-security"),
                                        (str("true") | str("false"))
                                      ),
                                      a(str("certificate-id"), arg),
                                      b(str("listen-addresses"),
                                        time_of_day
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("ssh-server"),
                          c(
                              b(str("config"),
                                  c(
                                      b(str("enable"),
                                        (str("true") | str("false"))
                                      ),
                                      b(str("protocol-version"),
                                        (str("V2") | str("V1") | str("V1_V2"))
                                      ),
                                      a(str("timeout"), arg),
                                      a(str("rate-limit"), arg),
                                      a(str("session-limit"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("telnet-server"),
                          c(
                              b(str("config"),
                                  c(
                                      b(str("enable"),
                                        (str("true") | str("false"))
                                      ),
                                      a(str("timeout"), arg),
                                      a(str("rate-limit"), arg),
                                      a(str("session-limit"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("logging"),
                          c(
                              b(str("console"),
                                  c(
                                      str("config"),
                                      b(str("selectors"),
                                          c(
                                              b(str("selector"),
                                                  s(
                                                          arg,
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("facility"),
                                                                (str("LOCAL7") | str("LOCAL6") | str("LOCAL5") | str("LOCAL4") | str("LOCAL3") | str("LOCAL2") | str("LOCAL1") | str("LOCAL0") | str("CONSOLE") | str("AUDIT") | str("NTP") | str("AUTHPRIV") | str("SYSLOG") | str("AUTH") | str("SYSTEM_DAEMON") | str("MAIL") | str("USER") | str("KERNEL") | str("ALL"))
                                                              ),
                                                              b(str("severity"),
                                                                (str("EMERGENCY") | str("ALERT") | str("CRITICAL") | str("ERROR") | str("WARNING") | str("NOTICE") | str("INFORMATIONAL") | str("DEBUG"))
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("remote-servers"),
                                  c(
                                      b(str("remote-server"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      b(str("host"),
                                                        time_of_day
                                                      ),
                                                      b(str("source-address"),
                                                        time_of_day
                                                      ),
                                                      a(str("remote-port"), arg)
                                                  )
                                              ),
                                              b(str("selectors"),
                                                  c(
                                                      b(str("selector"),
                                                          s(
                                                                  arg,
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("facility"),
                                                                        (str("LOCAL7") | str("LOCAL6") | str("LOCAL5") | str("LOCAL4") | str("LOCAL3") | str("LOCAL2") | str("LOCAL1") | str("LOCAL0") | str("CONSOLE") | str("AUDIT") | str("NTP") | str("AUTHPRIV") | str("SYSLOG") | str("AUTH") | str("SYSTEM_DAEMON") | str("MAIL") | str("USER") | str("KERNEL") | str("ALL"))
                                                                      ),
                                                                      b(str("severity"),
                                                                        (str("EMERGENCY") | str("ALERT") | str("CRITICAL") | str("ERROR") | str("WARNING") | str("NOTICE") | str("INFORMATIONAL") | str("DEBUG"))
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("aaa"),
                          c(
                              str("config"),
                              b(str("authentication"),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("authentication-method"), arg)
                                          )
                                      ),
                                      b(str("admin-user"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("admin-password"),
                                                        unreadable
                                                      ),
                                                      a(str("admin-password-hashed"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("users"),
                                          c(
                                              b(str("user"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("username"), arg),
                                                              b(str("password"),
                                                                unreadable
                                                              ),
                                                              a(str("password-hashed"), arg),
                                                              a(str("ssh-key"), quote | arg),
                                                              a(str("role"), arg)
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("authorization"),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("authorization-method"), arg)
                                          )
                                      ),
                                      b(str("events"),
                                          c(
                                              b(str("event"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("event-type"),
                                                                (str("AAA_AUTHORIZATION_EVENT_CONFIG") | str("AAA_AUTHORIZATION_EVENT_COMMAND"))
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("accounting"),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("accounting-method"), arg)
                                          )
                                      ),
                                      b(str("events"),
                                          c(
                                              b(str("event"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("event-type"),
                                                                (str("AAA_ACCOUNTING_EVENT_LOGIN") | str("AAA_ACCOUNTING_EVENT_COMMAND"))
                                                              ),
                                                              b(str("record"),
                                                                (str("START_STOP") | str("STOP"))
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("server-groups"),
                                  c(
                                      b(a(str("server-group"), arg),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("name"), arg),
                                                      b(str("type"),
                                                        (str("TACACS") | str("RADIUS"))
                                                      )
                                                  )
                                              ),
                                              b(str("servers"),
                                                  c(
                                                      b(str("server"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("name"), arg),
                                                                      b(str("address"),
                                                                        time_of_day
                                                                      ),
                                                                      a(str("timeout"), arg)
                                                                  )
                                                              ),
                                                              b(str("tacacs"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("port"), arg),
                                                                              b(str("secret-key"),
                                                                                unreadable
                                                                              ),
                                                                              b(str("source-address"),
                                                                                time_of_day
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("radius"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("auth-port"), arg),
                                                                              a(str("acct-port"), arg),
                                                                              b(str("secret-key"),
                                                                                unreadable
                                                                              ),
                                                                              b(str("source-address"),
                                                                                time_of_day
                                                                              ),
                                                                              a(str("retransmit-attempts"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("memory"),
                          c(
                              str("config")
                          )
                      ),
                      str("processes")
                  )
              ),
              b(str("openconfig-bgp:bgp"),
                  c(
                      b(str("global"),
                          c(
                              b(str("config"),
                                  c(
                                      a(str("as"), arg),
                                      a(str("router-id"), arg)
                                  )
                              ),
                              b(str("default-route-distance"),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("external-route-distance"), arg),
                                              a(str("internal-route-distance"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("confederation"),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("identifier"), arg),
                                              a(str("member-as"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("graceful-restart"),
                                  c(
                                      b(str("config"),
                                          c(
                                              b(str("enabled"),
                                                (str("true") | str("false"))
                                              ),
                                              a(str("restart-time"), arg),
                                              a(str("stale-routes-time"), arg),
                                              b(str("helper-only"),
                                                (str("true") | str("false"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("use-multiple-paths"),
                                  c(
                                      b(str("config"),
                                          c(
                                              b(str("enabled"),
                                                (str("true") | str("false"))
                                              )
                                          )
                                      ),
                                      b(str("ebgp"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("allow-multiple-as"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      a(str("maximum-paths"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("ibgp"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("maximum-paths"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("route-selection-options"),
                                  c(
                                      b(str("config"),
                                          c(
                                              b(str("always-compare-med"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("ignore-as-path-length"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("external-compare-router-id"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("advertise-inactive-routes"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("enable-aigp"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("ignore-next-hop-igp-metric"),
                                                (str("true") | str("false"))
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("afi-safis"),
                                  c(
                                      b(str("afi-safi"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      b(str("afi-safi-name"),
                                                        (str("L2VPN_EVPN") | str("L2VPN_VPLS") | str("L3VPN_IPV6_MULTICAST") | str("L3VPN_IPV4_MULTICAST") | str("L3VPN_IPV6_UNICAST") | str("L3VPN_IPV4_UNICAST") | str("IPV6_LABELED_UNICAST") | str("IPV4_LABELED_UNICAST") | str("IPV6_UNICAST") | str("IPV4_UNICAST") | str("IPV4_MULTICAST") | str("IPV6_MULTICAST"))
                                                      ),
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              ),
                                              b(str("graceful-restart"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("enabled"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("route-selection-options"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("always-compare-med"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              b(str("ignore-as-path-length"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              b(str("external-compare-router-id"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              b(str("advertise-inactive-routes"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              b(str("enable-aigp"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              b(str("ignore-next-hop-igp-metric"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("use-multiple-paths"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("enabled"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("ebgp"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("allow-multiple-as"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("maximum-paths"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ibgp"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("maximum-paths"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("add-paths"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("receive"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              b(str("send"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("send-max"), arg),
                                                              a(str("eligible-prefix-policy"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("ipv4-unicast"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("config"),
                                                          c(
                                                              b(str("send-default-route"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("ipv6-unicast"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("config"),
                                                          c(
                                                              b(str("send-default-route"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("ipv4-labeled-unicast"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("ipv6-labeled-unicast"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("l3vpn-ipv4-unicast"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("l3vpn-ipv6-unicast"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("l3vpn-ipv4-multicast"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("l3vpn-ipv6-multicast"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("l2vpn-vpls"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("l2vpn-evpn"),
                                                  c(
                                                      b(str("prefix-limit"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("max-prefixes"), arg),
                                                                      b(str("prevent-teardown"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("shutdown-threshold-pct"), arg),
                                                                      a(str("restart-timer"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("dynamic-neighbor-prefixes"),
                                  c(
                                      b(str("dynamic-neighbor-prefix"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      b(str("prefix"),
                                                        time_of_day
                                                      ),
                                                      a(str("peer-group"), arg)
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("neighbors"),
                          c(
                              b(str("neighbor"),
                                  s(
                                          arg,
                                    c(
                                      b(str("config"),
                                          c(
                                              a(str("peer-group"), arg),
                                              b(str("neighbor-address"),
                                                time_of_day
                                              ),
                                              b(str("enabled"),
                                                (str("true") | str("false"))
                                              ),
                                              a(str("peer-as"), arg),
                                              a(str("local-as"), arg),
                                              b(str("peer-type"),
                                                (str("INTERNAL") | str("EXTERNAL"))
                                              ),
                                              a(str("auth-password"), arg),
                                              b(str("remove-private-as"),
                                                (str("PRIVATE_AS_REPLACE_ALL") | str("PRIVATE_AS_REMOVE_ALL"))
                                              ),
                                              b(str("route-flap-damping"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("send-community"),
                                                (str("STANDARD") | str("EXTENDED") | str("BOTH") | str("NONE"))
                                              ),
                                              a(str("description"), quote | arg)
                                          )
                                      ),
                                      b(str("timers"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("connect-retry"), arg),
                                                      a(str("hold-time"), arg),
                                                      a(str("keepalive-interval"), arg),
                                                      a(str("minimum-advertisement-interval"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("transport"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("tcp-mss"), arg),
                                                      b(str("mtu-discovery"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      b(str("passive-mode"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      b(str("local-address"),
                                                        time_of_day
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("error-handling"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("treat-as-withdraw"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("graceful-restart"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      a(str("restart-time"), arg),
                                                      a(str("stale-routes-time"), arg),
                                                      b(str("helper-only"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("logging-options"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("log-neighbor-state-changes"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("ebgp-multihop"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      a(str("multihop-ttl"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("route-reflector"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("route-reflector-cluster-id"),
                                                        time_of_day
                                                      ),
                                                      b(str("route-reflector-client"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("as-path-options"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("allow-own-as"), arg),
                                                      b(str("replace-peer-as"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      b(str("disable-peer-as-filter"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("use-multiple-paths"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              ),
                                              b(str("ebgp"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("allow-multiple-as"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("apply-policy"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("import-policy"), arg),
                                                      b(str("default-import-policy"),
                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                      ),
                                                      a(str("export-policy"), arg),
                                                      b(str("default-export-policy"),
                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("afi-safis"),
                                          c(
                                              b(str("afi-safi"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("afi-safi-name"),
                                                                (str("L2VPN_EVPN") | str("L2VPN_VPLS") | str("L3VPN_IPV6_MULTICAST") | str("L3VPN_IPV4_MULTICAST") | str("L3VPN_IPV6_UNICAST") | str("L3VPN_IPV4_UNICAST") | str("IPV6_LABELED_UNICAST") | str("IPV4_LABELED_UNICAST") | str("IPV6_UNICAST") | str("IPV4_UNICAST") | str("IPV4_MULTICAST") | str("IPV6_MULTICAST"))
                                                              ),
                                                              b(str("enabled"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("graceful-restart"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("enabled"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("add-paths"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("receive"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      b(str("send"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("send-max"), arg),
                                                                      a(str("eligible-prefix-policy"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("apply-policy"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("import-policy"), arg),
                                                                      b(str("default-import-policy"),
                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                      ),
                                                                      a(str("export-policy"), arg),
                                                                      b(str("default-export-policy"),
                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ipv4-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("send-default-route"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ipv6-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("send-default-route"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ipv4-labeled-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ipv6-labeled-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l3vpn-ipv4-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l3vpn-ipv6-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l3vpn-ipv4-multicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l3vpn-ipv6-multicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l2vpn-vpls"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l2vpn-evpn"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("use-multiple-paths"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("enabled"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("ebgp"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("allow-multiple-as"),
                                                                                (str("true") | str("false"))
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                    )
                                  )
                              )
                          )
                      ),
                      b(str("peer-groups"),
                          c(
                              b(str("peer-group"),
                                  s(
                                          arg,
                                    c(
                                      b(str("config"),
                                          c(
                                              a(str("peer-group-name"), arg),
                                              a(str("peer-as"), arg),
                                              a(str("local-as"), arg),
                                              b(str("peer-type"),
                                                (str("INTERNAL") | str("EXTERNAL"))
                                              ),
                                              a(str("auth-password"), arg),
                                              b(str("remove-private-as"),
                                                (str("PRIVATE_AS_REPLACE_ALL") | str("PRIVATE_AS_REMOVE_ALL"))
                                              ),
                                              b(str("route-flap-damping"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("send-community"),
                                                (str("STANDARD") | str("EXTENDED") | str("BOTH") | str("NONE"))
                                              ),
                                              a(str("description"), quote | arg)
                                          )
                                      ),
                                      b(str("timers"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("connect-retry"), arg),
                                                      a(str("hold-time"), arg),
                                                      a(str("keepalive-interval"), arg),
                                                      a(str("minimum-advertisement-interval"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("transport"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("tcp-mss"), arg),
                                                      b(str("mtu-discovery"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      b(str("passive-mode"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      b(str("local-address"),
                                                        time_of_day
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("error-handling"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("treat-as-withdraw"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("graceful-restart"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      a(str("restart-time"), arg),
                                                      a(str("stale-routes-time"), arg),
                                                      b(str("helper-only"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("logging-options"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("log-neighbor-state-changes"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("ebgp-multihop"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      a(str("multihop-ttl"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("route-reflector"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("route-reflector-cluster-id"),
                                                        time_of_day
                                                      ),
                                                      b(str("route-reflector-client"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("as-path-options"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("allow-own-as"), arg),
                                                      b(str("replace-peer-as"),
                                                        (str("true") | str("false"))
                                                      ),
                                                      b(str("disable-peer-as-filter"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("use-multiple-paths"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("enabled"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              ),
                                              b(str("ebgp"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("allow-multiple-as"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("maximum-paths"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("ibgp"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("maximum-paths"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("apply-policy"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("import-policy"), arg),
                                                      b(str("default-import-policy"),
                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                      ),
                                                      a(str("export-policy"), arg),
                                                      b(str("default-export-policy"),
                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("afi-safis"),
                                          c(
                                              b(str("afi-safi"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("afi-safi-name"),
                                                                (str("L2VPN_EVPN") | str("L2VPN_VPLS") | str("L3VPN_IPV6_MULTICAST") | str("L3VPN_IPV4_MULTICAST") | str("L3VPN_IPV6_UNICAST") | str("L3VPN_IPV4_UNICAST") | str("IPV6_LABELED_UNICAST") | str("IPV4_LABELED_UNICAST") | str("IPV6_UNICAST") | str("IPV4_UNICAST") | str("IPV4_MULTICAST") | str("IPV6_MULTICAST"))
                                                              ),
                                                              b(str("enabled"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("graceful-restart"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("enabled"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("add-paths"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("receive"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      b(str("send"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("send-max"), arg),
                                                                      a(str("eligible-prefix-policy"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("use-multiple-paths"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("enabled"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("ebgp"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("allow-multiple-as"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("maximum-paths"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("ibgp"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("maximum-paths"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("apply-policy"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("import-policy"), arg),
                                                                      b(str("default-import-policy"),
                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                      ),
                                                                      a(str("export-policy"), arg),
                                                                      b(str("default-export-policy"),
                                                                        (str("ACCEPT_ROUTE") | str("REJECT_ROUTE"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ipv4-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("send-default-route"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ipv6-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("send-default-route"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ipv4-labeled-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("ipv6-labeled-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l3vpn-ipv4-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l3vpn-ipv6-unicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l3vpn-ipv4-multicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l3vpn-ipv6-multicast"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l2vpn-vpls"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("l2vpn-evpn"),
                                                          c(
                                                              b(str("prefix-limit"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              a(str("max-prefixes"), arg),
                                                                              b(str("prevent-teardown"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("shutdown-threshold-pct"), arg),
                                                                              a(str("restart-timer"), arg)
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                    )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-lacp:lacp"),
                  c(
                      b(str("config"),
                          c(
                              a(str("system-priority"), arg)
                          )
                      ),
                      b(str("interfaces"),
                          c(
                              b(a(str("interface"), arg),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("name"), arg),
                                              b(str("interval"),
                                                (str("FAST") | str("SLOW"))
                                              ),
                                              b(str("lacp-mode"),
                                                (str("ACTIVE") | str("PASSIVE"))
                                              ),
                                              a(str("system-id-mac"), arg),
                                              a(str("system-priority"), arg)
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-local-routing:local-routes"),
                  c(
                      str("config"),
                      b(str("static-routes"),
                          c(
                              b(str("static"),
                                  s(
                                          arg,
                                    c(
                                      b(str("config"),
                                          c(
                                              b(str("prefix"),
                                                time_of_day
                                              ),
                                              b(str("set-tag"),
                                                time_of_day
                                              )
                                          )
                                      ),
                                      b(str("next-hops"),
                                          c(
                                              b(str("next-hop"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("index"), arg),
                                                              a(str("next-hop"), arg),
                                                              a(str("metric"), arg),
                                                              b(str("recurse"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("jnx-aug-openconfig-local-routing:interface-id"), arg),
                                                              b(str("set-tag"),
                                                                time_of_day
                                                              )
                                                          )
                                                      ),
                                                      b(str("interface-ref"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("interface"), arg),
                                                                      a(str("subinterface"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                    )
                                  )
                              )
                          )
                      ),
                      b(str("local-aggregates"),
                          c(
                              b(str("aggregate"),
                                  s(
                                          arg,
                                    c(
                                      b(str("config"),
                                          c(
                                              b(str("prefix"),
                                                time_of_day
                                              ),
                                              b(str("discard"),
                                                (str("true") | str("false"))
                                              ),
                                              b(str("set-tag"),
                                                time_of_day
                                              )
                                          )
                                      )
                                    )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("openconfig-mpls:mpls"),
                  c(
                      b(str("global"),
                          c(
                              b(str("config"),
                                  c(
                                      b(str("null-label"),
                                        (str("IMPLICIT") | str("EXPLICIT"))
                                      )
                                  )
                              ),
                              b(str("interface-attributes"),
                                  c(
                                      b(str("interface"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("interface-id"), arg),
                                                      b(str("mpls-enabled"),
                                                        (str("true") | str("false"))
                                                      )
                                                  )
                                              ),
                                              b(str("interface-ref"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("interface"), arg),
                                                              a(str("subinterface"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("reserved-label-blocks"),
                                  c(
                                      b(str("reserved-label-block"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("local-id"), arg),
                                                      b(str("lower-bound"),
                                                        time_of_day
                                                      ),
                                                      b(str("upper-bound"),
                                                        time_of_day
                                                      )
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("te-global-attributes"),
                          c(
                              b(str("srlgs"),
                                  c(
                                      b(a(str("srlg"), arg),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("name"), arg),
                                                      a(str("value"), arg),
                                                      a(str("cost"), arg),
                                                      b(str("flooding-type"),
                                                        (str("FLOODED_SRLG") | str("STATIC_SRLG"))
                                                      )
                                                  )
                                              ),
                                              b(str("static-srlg-members"),
                                                  c(
                                                      b(str("members-list"),
                                                          s(
                                                                  arg,
                                                            c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("from-address"),
                                                                        time_of_day
                                                                      ),
                                                                      b(str("to-address"),
                                                                        time_of_day
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("mpls-admin-groups"),
                                  c(
                                      b(str("admin-group"),
                                          s(
                                                  arg,
                                            c(
                                              b(str("config"),
                                                  c(
                                                      a(str("admin-group-name"), arg),
                                                      a(str("bit-position"), arg)
                                                  )
                                              )
                                            )
                                          )
                                      )
                                  )
                              ),
                              b(str("te-lsp-timers"),
                                  c(
                                      b(str("config"),
                                          c(
                                              a(str("install-delay"), arg),
                                              a(str("cleanup-delay"), arg),
                                              a(str("reoptimize-timer"), arg)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("te-interface-attributes"),
                          c(
                              b(str("interface"),
                                  s(
                                          arg,
                                    c(
                                      b(str("config"),
                                          c(
                                              a(str("interface-id"), arg),
                                              a(str("te-metric"), arg),
                                              a(str("srlg-membership"), arg),
                                              a(str("admin-group"), arg)
                                          )
                                      ),
                                      b(str("interface-ref"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("interface"), arg),
                                                      a(str("subinterface"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("igp-flooding-bandwidth"),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      b(str("threshold-type"),
                                                        (str("DELTA") | str("THRESHOLD_CROSSED"))
                                                      ),
                                                      a(str("delta-percentage"), arg),
                                                      b(str("threshold-specification"),
                                                        (str("MIRRORED_UP_DOWN") | str("SEPARATE_UP_DOWN"))
                                                      ),
                                                      a(str("up-thresholds"), arg),
                                                      a(str("down-thresholds"), arg),
                                                      a(str("up-down-thresholds"), arg)
                                                  )
                                              )
                                          )
                                      )
                                    )
                                  )
                              )
                          )
                      ),
                      b(str("signaling-protocols"),
                          c(
                              b(str("rsvp-te"),
                                  c(
                                      str("sessions"),
                                      str("neighbors"),
                                      b(str("global"),
                                          c(
                                              b(str("graceful-restart"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("enable"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("restart-time"), arg),
                                                              a(str("recovery-time"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("soft-preemption"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("enable"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("soft-preemption-timeout"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("hellos"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("hello-interval"), arg),
                                                              b(str("refresh-reduction"),
                                                                (str("true") | str("false"))
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("interface-attributes"),
                                          c(
                                              b(str("interface"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("interface-id"), arg)
                                                          )
                                                      ),
                                                      b(str("interface-ref"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("interface"), arg),
                                                                      a(str("subinterface"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      str("bandwidth-reservations"),
                                                      b(str("hellos"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("hello-interval"), arg),
                                                                      b(str("refresh-reduction"),
                                                                        (str("true") | str("false"))
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("authentication"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("enable"),
                                                                        (str("true") | str("false"))
                                                                      ),
                                                                      a(str("authentication-key"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("subscription"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("subscription"), arg)
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("protection"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("link-protection-style-requested"),
                                                                        (str("LINK_NODE_PROTECTION_REQUESTED") | str("LINK_PROTECTION_REQUIRED") | str("UNPROTECTED"))
                                                                      ),
                                                                      a(str("bypass-optimize-interval"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("ldp"),
                                  c(
                                      b(str("jnx-aug-openconfig-mpls:lsp-ingress-policies"),
                                          c(
                                              b(str("lsp-ingress-policy"),
                                                  s(
                                                          arg,
                                                    c(
                                                      str("state")
                                                    )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("jnx-aug-openconfig-mpls:lsp-transit-policies"),
                                          c(
                                              b(str("lsp-transit-policy"),
                                                  s(
                                                          arg,
                                                    c(
                                                      str("state")
                                                    )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("jnx-aug-openconfig-mpls:p2mp-lsps"),
                                          c(
                                              b(str("p2mp-lsp"),
                                                  s(
                                                          arg,
                                                          arg,
                                                          arg,
                                                          arg,
                                                    c(
                                                      str("state")
                                                    )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("jnx-aug-openconfig-mpls:p2mp-lsp-branches"),
                                          c(
                                              b(str("p2mp-lsp-branch"),
                                                  s(
                                                          arg,
                                                          arg,
                                                          arg,
                                                          arg,
                                                          arg,
                                                    c(
                                                      str("state")
                                                    )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("jnx-aug-openconfig-mpls:p2mp-interfaces"),
                                          c(
                                              b(str("p2mp-interface"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("state"),
                                                          c(
                                                              str("received-counters"),
                                                              str("transmit-counters")
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("segment-routing"),
                                  c(
                                      str("aggregate-sid-counters"),
                                      b(str("interfaces"),
                                          c(
                                              b(str("interface"),
                                                  s(
                                                          arg,
                                                    c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("interface-id"), arg)
                                                          )
                                                      ),
                                                      str("sid-counters"),
                                                      b(str("interface-ref"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      a(str("interface"), arg),
                                                                      a(str("subinterface"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                    )
                                                  )
                                              )
                                          )
                                      ),
                                      str("jnx-aug-openconfig-mpls:sr-te-bsid-policies"),
                                      str("jnx-aug-openconfig-mpls:sr-te-ip-policies"),
                                      str("jnx-aug-openconfig-mpls:sr-te-transit-tunnel-policies"),
                                      str("jnx-aug-openconfig-mpls:sr-te-ingress-tunnel-policies")
                                  )
                              )
                          )
                      ),
                      b(str("lsps"),
                          c(
                              b(str("constrained-path"),
                                  c(
                                      b(str("named-explicit-paths"),
                                          c(
                                              b(a(str("named-explicit-path"), arg),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("name"), arg)
                                                          )
                                                      ),
                                                      b(str("explicit-route-objects"),
                                                          c(
                                                              b(str("explicit-route-object"),
                                                                  s(
                                                                          arg,
                                                                    c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("address"),
                                                                                time_of_day
                                                                              ),
                                                                              b(str("hop-type"),
                                                                                (str("LOOSE") | str("STRICT"))
                                                                              ),
                                                                              a(str("index"), arg)
                                                                          )
                                                                      )
                                                                    )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("tunnels"),
                                          c(
                                              b(a(str("tunnel"), arg),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              a(str("name"), arg),
                                                              b(str("type"),
                                                                (str("P2MP") | str("P2P"))
                                                              ),
                                                              b(str("signaling-protocol"),
                                                                (str("PATH_SETUP_LDP") | str("PATH_SETUP_SR") | str("PATH_SETUP_RSVP"))
                                                              ),
                                                              a(str("description"), quote | arg),
                                                              b(str("admin-status"),
                                                                (str("ADMIN_UP") | str("ADMIN_DOWN"))
                                                              ),
                                                              a(str("preference"), arg),
                                                              b(str("metric-type"),
                                                                (str("LSP_METRIC_INHERITED") | str("LSP_METRIC_ABSOLUTE") | str("LSP_METRIC_RELATIVE"))
                                                              ),
                                                              a(str("metric"), arg),
                                                              b(str("shortcut-eligible"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              b(str("protection-style-requested"),
                                                                (str("LINK_NODE_PROTECTION_REQUESTED") | str("LINK_PROTECTION_REQUIRED") | str("UNPROTECTED"))
                                                              ),
                                                              a(str("reoptimize-timer"), arg),
                                                              b(str("source"),
                                                                time_of_day
                                                              ),
                                                              b(str("soft-preemption"),
                                                                (str("true") | str("false"))
                                                              ),
                                                              a(str("setup-priority"), arg),
                                                              a(str("hold-priority"), arg)
                                                          )
                                                      ),
                                                      b(str("bandwidth"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("specification-type"),
                                                                        (str("SPECIFIED") | str("AUTO"))
                                                                      ),
                                                                      a(str("set-bandwidth"), arg)
                                                                  )
                                                              ),
                                                              b(str("auto-bandwidth"),
                                                                  c(
                                                                      b(str("config"),
                                                                          c(
                                                                              b(str("enabled"),
                                                                                (str("true") | str("false"))
                                                                              ),
                                                                              a(str("min-bw"), arg),
                                                                              a(str("max-bw"), arg),
                                                                              a(str("adjust-interval"), arg),
                                                                              a(str("adjust-threshold"), arg)
                                                                          )
                                                                      ),
                                                                      b(str("overflow"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("overflow-threshold"), arg),
                                                                                      a(str("trigger-event-count"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      ),
                                                                      b(str("underflow"),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      b(str("enabled"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      a(str("underflow-threshold"), arg),
                                                                                      a(str("trigger-event-count"), arg)
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      b(str("p2p-tunnel-attributes"),
                                                          c(
                                                              b(str("config"),
                                                                  c(
                                                                      b(str("destination"),
                                                                        time_of_day
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("p2p-primary-path"),
                                                                  c(
                                                                      b(a(str("p2p-primary-path"), arg),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("name"), arg),
                                                                                      b(str("path-computation-method"),
                                                                                        (str("EXPLICITLY_DEFINED") | str("EXTERNALLY_QUERIED") | str("LOCALLY_COMPUTED"))
                                                                                      ),
                                                                                      b(str("use-cspf"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("cspf-tiebreaker"),
                                                                                        (str("RANDOM") | str("LEAST_FILL") | str("MOST_FILL"))
                                                                                      ),
                                                                                      b(str("path-computation-server"),
                                                                                        time_of_day
                                                                                      ),
                                                                                      a(str("explicit-path-name"), arg),
                                                                                      a(str("preference"), arg),
                                                                                      a(str("setup-priority"), arg),
                                                                                      a(str("hold-priority"), arg),
                                                                                      a(str("retry-timer"), arg)
                                                                                  )
                                                                              ),
                                                                              b(str("candidate-secondary-paths"),
                                                                                  c(
                                                                                      b(str("candidate-secondary-path"),
                                                                                          s(
                                                                                                  arg,
                                                                                            c(
                                                                                              b(str("config"),
                                                                                                  c(
                                                                                                      a(str("secondary-path"), arg),
                                                                                                      a(str("priority"), arg)
                                                                                                  )
                                                                                              )
                                                                                            )
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("admin-groups"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("exclude-group"), arg),
                                                                                              a(str("include-all-group"), arg),
                                                                                              a(str("include-any-group"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              ),
                                                                              b(str("jnx-aug-openconfig-mpls:lsp-instances"),
                                                                                  s(
                                                                                          arg,
                                                                                    c(
                                                                                      b(str("state"),
                                                                                          c(
                                                                                              a(str("local-index"), arg),
                                                                                              a(str("notify-status"), arg),
                                                                                              a(str("metric"), arg),
                                                                                              a(str("bandwidth"), arg),
                                                                                              a(str("max-average-bandwidth"), arg)
                                                                                          )
                                                                                      )
                                                                                    )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              ),
                                                              b(str("p2p-secondary-paths"),
                                                                  c(
                                                                      b(a(str("p2p-secondary-path"), arg),
                                                                          c(
                                                                              b(str("config"),
                                                                                  c(
                                                                                      a(str("name"), arg),
                                                                                      b(str("path-computation-method"),
                                                                                        (str("EXPLICITLY_DEFINED") | str("EXTERNALLY_QUERIED") | str("LOCALLY_COMPUTED"))
                                                                                      ),
                                                                                      b(str("use-cspf"),
                                                                                        (str("true") | str("false"))
                                                                                      ),
                                                                                      b(str("cspf-tiebreaker"),
                                                                                        (str("RANDOM") | str("LEAST_FILL") | str("MOST_FILL"))
                                                                                      ),
                                                                                      b(str("path-computation-server"),
                                                                                        time_of_day
                                                                                      ),
                                                                                      a(str("explicit-path-name"), arg),
                                                                                      a(str("preference"), arg),
                                                                                      a(str("setup-priority"), arg),
                                                                                      a(str("hold-priority"), arg),
                                                                                      a(str("retry-timer"), arg)
                                                                                  )
                                                                              ),
                                                                              b(str("admin-groups"),
                                                                                  c(
                                                                                      b(str("config"),
                                                                                          c(
                                                                                              a(str("exclude-group"), arg),
                                                                                              a(str("include-all-group"), arg),
                                                                                              a(str("include-any-group"), arg)
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("unconstrained-path"),
                                  c(
                                      b(str("path-setup-protocol"),
                                          c(
                                              str("ldp")
                                          )
                                      )
                                  )
                              ),
                              b(str("static-lsps"),
                                  c(
                                      b(a(str("static-lsp"), arg),
                                          c(
                                              b(str("config"),
                                                  c(
                                                      a(str("name"), arg)
                                                  )
                                              ),
                                              b(str("ingress"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("next-hop"),
                                                                time_of_day
                                                              ),
                                                              b(str("incoming-label"),
                                                                time_of_day
                                                              ),
                                                              b(str("push-label"),
                                                                time_of_day
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("transit"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("next-hop"),
                                                                time_of_day
                                                              ),
                                                              b(str("incoming-label"),
                                                                time_of_day
                                                              ),
                                                              b(str("push-label"),
                                                                time_of_day
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("egress"),
                                                  c(
                                                      b(str("config"),
                                                          c(
                                                              b(str("next-hop"),
                                                                time_of_day
                                                              ),
                                                              b(str("incoming-label"),
                                                                time_of_day
                                                              ),
                                                              b(str("push-label"),
                                                                time_of_day
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                  )
              )
          )
    end

    rule(:aaa_profile) do
      b(arg.as(:arg),
        c(
            b(str("radius"),
              aaa_profile_radius
            )
        )
      )
    end

    rule(:aaa_profile_radius) do
        c(
            b(str("authentication"),
                c(
                    a(str("network-element"), arg)
                )
            ),
            b(str("accounting"),
                c(
                    a(str("network-element"), arg)
                )
            ),
            b(str("policy"),
                c(
                    b(str("activation-attribute"),
                        c(
                            a(str("code"), arg),
                            a(str("vendor-id"), arg)
                        )
                    ),
                    b(str("deactivation-attribute"),
                        c(
                            a(str("code"), arg),
                            a(str("vendor-id"), arg)
                        )
                    ),
                    b(str("coa-accounting"),
                      (str("allow") | str("disallow"))
                    )
                )
            )
        )
    end

    rule(:aaa_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("init") | str("config") | str("general") | str("request") | str("response") | str("high-availability") | str("debug") | str("request-in") | str("request-out") | str("response-in") | str("response-out") | str("client-request-in") | str("client-request-out") | str("all"))).as(:oneline),
            a(str("protocol"), enum(str("radius") | str("diameter") | str("all"))).as(:oneline)
        )
    end

    rule(:aacl_rule_object) do
      b(arg.as(:arg),
        c(
            str("dynamic"),
            b(str("match-direction"),
              (str("input") | str("output") | str("input-output"))
            ),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      aacl_match_object
                    ),
                    b(str("then"),
                        c(
                            a(str("forwarding-class"), arg),
                            b(str("count"),
                              (str("none") | str("application") | str("application-group") | str("application-group-any") | str("nested-application"))
                            ),
                            b(str("log"),
                              (str("none") | str("session-start") | str("session-start-end") | str("session-start-end-no-stats") | str("session-start-interim-end") | str("session-interim-end") | str("session-end"))
                            ),
                            a(str("police"), arg),
                            c(
                              str("accept"),
                              str("discard")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:aacl_match_object) do
        c(
            b(str("source-address"),
              sfw_addr_object
            ),
            b(str("destination-address"),
              sfw_addr_object
            ),
            b(str("source-address-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg),
                  c(
                    str("except")
                  )
                )
            ).as(:oneline),
            b(a(str("source-prefix-list"), arg),
                sc(
                    str("except")
                )
            ).as(:oneline),
            b(str("destination-address-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg),
                  c(
                    str("except")
                  )
                )
            ).as(:oneline),
            b(a(str("destination-prefix-list"), arg),
                sc(
                    str("except")
                )
            ).as(:oneline),
            c(
              str("application-group-any"),
              str("application-unknown"),
              str("nested-application-unknown"),
              a(str("applications"), arg),
              a(str("nested-applications"), arg),
              a(str("application-groups"), arg)
            )
        )
    end

    rule(:advisory_options_type) do
        c(
            a(str("upstream-rate"), arg),
            a(str("downstream-rate"), arg)
        )
    end

    rule(:aggregate_load_balance) do
        c(
            c(
              str("per-packet"),
              str("no-adaptive"),
              b(str("adaptive"),
                  c(
                      a(str("tolerance"), arg),
                      str("pps"),
                      a(str("scan-interval"), arg)
                  )
              )
            ),
            a(str("local-bias"), arg)
        )
    end

    rule(:any_filter) do
      b(arg.as(:arg),
        c(
            str("interface-specific"),
            str("interface-shared"),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("interface"),
                              match_interface_object_oam
                            ),
                            b(str("interface-set"),
                              match_interface_set_object
                            ),
                            c(
                              a(str("packet-length"), arg),
                              a(str("packet-length-except"), arg)
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            c(
                              a(str("policy-map"), arg),
                              a(str("policy-map-except"), arg)
                            ),
                            str("service-filter-hit")
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("single-packet-rate"), arg),
                                        a(str("two-rate"), arg),
                                        a(str("two-packet-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            c(
                              str("clear-policy-map"),
                              a(str("policy-map"), arg)
                            ),
                            a(str("count"), arg),
                            str("service-accounting"),
                            str("service-accounting-deferred"),
                            str("service-filter-hit"),
                            str("force-premium"),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("forwarding-class"), arg),
                            c(
                              b(str("encapsulate"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline),
                              str("accept"),
                              str("discard"),
                              b(str("next"),
                                (str("term"))
                              )
                            )
                        )
                    ),
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:any_template) do
      b(arg.as(:arg),
        c(
            b(str("attributes"),
                c(
                    str("forwarding-class"),
                    str("forwarding-class-except"),
                    str("interface"),
                    str("interface-set"),
                    str("loss-priority"),
                    str("loss-priority-except"),
                    str("packet-length"),
                    str("packet-length-except")
                )
            )
        )
      )
    end

    rule(:application_set_object) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("application"), arg),
            a(str("application-set"), arg)
        )
      )
    end

    rule(:aps_type) do
        c(
            c(
              a(str("working-circuit"), arg),
              a(str("protect-circuit"), arg)
            ),
            str("annex-b"),
            a(str("wait-to-restore-time"), arg),
            str("preserve-interface"),
            b(str("neighbor"),
              ipv4addr
            ),
            a(str("paired-group"), arg),
            b(str("authentication-key"),
                sc(
                      unreadable
                )
            ).as(:oneline),
            b(str("switching-mode"),
              (str("bidirectional") | str("unidirectional"))
            ),
            a(str("advertise-interval"), arg),
            a(str("hold-time"), arg),
            a(str("revert-time"), arg),
            str("break-before-make"),
            str("no-break-before-make"),
            c(
              b(str("request"),
                (str("protect") | str("working"))
              ),
              b(str("force"),
                (str("protect") | str("working"))
              ),
              str("lockout")
            ),
            str("fast-aps-switch")
        )
    end

    rule(:atm_policer_type) do
      b(arg.as(:arg),
        c(
            str("logical-interface-policer"),
            b(str("atm-service"),
              (str("cbr") | str("rtvbr") | str("nrtvbr") | str("ubr"))
            ),
            a(str("peak-rate"), arg),
            a(str("sustained-rate"), arg),
            a(str("max-burst-size"), arg),
            a(str("cdvt"), arg),
            b(str("policing-action"),
              (str("count") | str("discard") | str("discard-tag"))
            )
        )
      )
    end

    rule(:auto_configure_vlan_type) do
        c(
            b(str("stacked-vlan-ranges"),
                c(
                    b(a(str("dynamic-profile"), arg),
                        c(
                            b(str("accept"),
                                  enum((str("inet6") | str("inet") | str("pppoe") | str("dhcp-v4") | str("dhcp-v6") | str("any")))
                            ),
                            a(str("ranges"), arg),
                            b(str("access-profile"),
                                sc(
                                      arg
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("override"),
                        c(
                            b(a(str("outer-tag"), arg),
                                c(
                                    a(str("inner-tag"), arg),
                                    a(str("dynamic-profile"), arg)
                                )
                            )
                        )
                    ),
                    b(str("authentication"),
                      auto_configure_authentication_type
                    ),
                    b(str("access-profile"),
                        sc(
                              arg
                        )
                    ).as(:oneline)
                )
            ),
            b(str("vlan-ranges"),
                c(
                    b(a(str("dynamic-profile"), arg),
                        c(
                            c(
                              b(str("accept"),
                                    enum((str("inet6") | str("inet") | str("pppoe") | str("dhcp-v4") | str("dhcp-v6") | str("any")))
                              ),
                              b(str("accept-out-of-band"),
                                    enum((str("ancp")))
                              )
                            ),
                            a(str("ranges"), arg),
                            b(str("access-profile"),
                                sc(
                                      arg
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("override"),
                        c(
                            b(a(str("tag"), arg),
                                c(
                                    a(str("dynamic-profile"), arg)
                                )
                            )
                        )
                    ),
                    b(str("authentication"),
                      auto_configure_authentication_type
                    ),
                    b(str("access-profile"),
                        sc(
                              arg
                        )
                    ).as(:oneline)
                )
            ),
            b(str("agent-circuit-identifier"),
                c(
                    a(str("dynamic-profile"), arg)
                )
            ),
            b(str("line-identity"),
                c(
                    b(str("includes"),
                        c(
                            str("circuit-id"),
                            str("remote-id"),
                            str("accept-no-ids")
                        )
                    ),
                    a(str("dynamic-profile"), arg)
                )
            ),
            str("remove-when-no-subscribers")
        )
    end

    rule(:auto_configure_authentication_type) do
        c(
            b(str("packet-types"),
                  enum((str("inet6") | str("inet") | str("pppoe") | str("dhcp-v4") | str("dhcp-v6") | str("any")))
            ),
            a(str("password"), arg),
            b(str("username-include"),
                c(
                    a(str("delimiter"), arg),
                    a(str("domain-name"), arg),
                    a(str("user-prefix"), arg),
                    str("mac-address"),
                    b(str("option-82"),
                        sc(
                            str("circuit-id"),
                            str("remote-id")
                        )
                    ).as(:oneline),
                    str("option-18"),
                    str("option-37"),
                    str("circuit-type"),
                    a(str("radius-realm"), arg),
                    str("interface-name"),
                    str("vlan-tags")
                )
            )
        )
    end

    rule(:bbefwa_trace_options_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("configuration") | str("cli") | str("general") | str("statistics") | str("tunnel") | str("gateway") | str("authentication") | str("infra") | str("all"))).as(:oneline)
        )
    end

    rule(:bgp_logical_system) do
      b(arg.as(:arg),
        c(
            b(str("routing-instances"),
              bgp_routing_instances
            )
        )
      )
    end

    rule(:bgp_routing_instances) do
      arg.as(:arg)
    end

    rule(:bridge_filter) do
      b(arg.as(:arg),
        c(
            a(str("accounting-profile"), arg),
            str("interface-specific"),
            str("physical-interface-filter"),
            str("instance-shared"),
            b(a(str("term"), arg),
                c(
                    a(str("filter"), arg),
                    b(str("from"),
                        c(
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            c(
                              b(str("ether-type"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              ),
                              b(str("ether-type-except"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              )
                            ),
                            c(
                              b(str("vlan-ether-type"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              ),
                              b(str("vlan-ether-type-except"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              )
                            ),
                            b(str("destination-mac-address"),
                              firewall_mac_addr_object
                            ),
                            b(str("source-mac-address"),
                              firewall_mac_addr_object
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            c(
                              a(str("learn-vlan-id"), arg),
                              a(str("learn-vlan-id-except"), arg)
                            ),
                            c(
                              a(str("learn-vlan-1p-priority"), arg),
                              a(str("learn-vlan-1p-priority-except"), arg)
                            ),
                            c(
                              a(str("user-vlan-id"), arg),
                              a(str("user-vlan-id-except"), arg)
                            ),
                            c(
                              a(str("user-vlan-1p-priority"), arg),
                              a(str("user-vlan-1p-priority-except"), arg)
                            ),
                            c(
                              a(str("learn-vlan-dei"), arg),
                              a(str("learn-vlan-dei-except"), arg)
                            ),
                            c(
                              b(str("traffic-type"),
                                    (str("broadcast") | str("multicast") | str("unknown-unicast") | str("known-unicast"))
                              ),
                              b(str("traffic-type-except"),
                                    (str("broadcast") | str("multicast") | str("unknown-unicast") | str("known-unicast"))
                              )
                            ),
                            b(str("ip-source-address"),
                              firewall_addr_object
                            ),
                            b(str("ip-destination-address"),
                              firewall_addr_object
                            ),
                            b(str("ip-address"),
                              firewall_addr_object
                            ),
                            c(
                              b(str("ip-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ip-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("dscp"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("dscp-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            c(
                              b(str("ip-precedence"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              ),
                              b(str("ip-precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            a(str("tcp-flags"), arg),
                            c(
                              b(str("icmp-type"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              ),
                              b(str("icmp-type-except"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-code"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              ),
                              b(str("icmp-code-except"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              )
                            ),
                            b(str("interface"),
                              match_interface_object
                            ),
                            b(str("interface-set"),
                              match_interface_set_object
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ipv6-destination-address"),
                              firewall_addr6_object
                            ),
                            b(str("ipv6-source-address"),
                              firewall_addr6_object
                            ),
                            b(str("ipv6-address"),
                              firewall_addr6_object
                            ),
                            c(
                              b(str("ipv6-next-header"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ipv6-next-header-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("ipv6-payload-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ipv6-payload-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("ipv6-traffic-class"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("ipv6-traffic-class-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            b(str("ipv6-source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ipv6-destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ipv6-prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              b(str("flexible-match-mask"),
                                match_l2_flexible_mask
                              )
                            ),
                            c(
                              b(str("flexible-match-range"),
                                match_l2_flexible_range
                              )
                            ),
                            c(
                              a(str("policy-map"), arg),
                              a(str("policy-map-except"), arg)
                            ),
                            c(
                              a(str("isid"), arg),
                              a(str("isid-except"), arg)
                            ),
                            c(
                              a(str("isid-priority-code-point"), arg),
                              a(str("isid-priority-code-point-except"), arg)
                            ),
                            c(
                              a(str("isid-dei"), arg),
                              a(str("isid-dei-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("single-packet-rate"), arg),
                                        a(str("two-rate"), arg),
                                        a(str("two-packet-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            c(
                              str("clear-policy-map"),
                              a(str("policy-map"), arg)
                            ),
                            a(str("count"), arg),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("forwarding-class"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              b(str("next"),
                                (str("term"))
                              )
                            ),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("next-hop-group"), arg),
                            str("sample"),
                            str("log"),
                            str("syslog"),
                            b(str("forwarding-policy"),
                                c(
                                    a(str("uplink-select"), arg)
                                )
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:ccc_filter) do
      b(arg.as(:arg),
        c(
            a(str("accounting-profile"), arg),
            str("interface-specific"),
            str("physical-interface-filter"),
            b(a(str("term"), arg),
                c(
                    a(str("filter"), arg),
                    b(str("from"),
                        c(
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            c(
                              a(str("learn-vlan-1p-priority"), arg),
                              a(str("learn-vlan-1p-priority-except"), arg)
                            ),
                            c(
                              a(str("user-vlan-1p-priority"), arg),
                              a(str("user-vlan-1p-priority-except"), arg)
                            ),
                            b(str("destination-mac-address"),
                              firewall_mac_addr_object
                            ),
                            str("is-host-packet"),
                            b(str("source-mac-address"),
                              firewall_mac_addr_object
                            ),
                            b(str("ip-source-address"),
                              firewall_addr_object
                            ),
                            b(str("ip-destination-address"),
                              firewall_addr_object
                            ),
                            c(
                              b(str("dscp"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("dscp-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            c(
                              b(str("ip-precedence"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              ),
                              b(str("ip-precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              )
                            ),
                            c(
                              b(str("ip-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ip-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-type"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              ),
                              b(str("icmp-type-except"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-code"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              ),
                              b(str("icmp-code-except"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              a(str("policy-map"), arg),
                              a(str("policy-map-except"), arg)
                            ),
                            c(
                              b(str("flexible-match-mask"),
                                match_l2_flexible_mask
                              )
                            ),
                            c(
                              b(str("flexible-match-range"),
                                match_l2_flexible_range
                              )
                            ),
                            c(
                              a(str("user-vlan-id"), arg),
                              a(str("user-vlan-id-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("single-packet-rate"), arg),
                                        a(str("two-rate"), arg),
                                        a(str("two-packet-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            c(
                              str("clear-policy-map"),
                              a(str("policy-map"), arg)
                            ),
                            a(str("count"), arg),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("forwarding-class"), arg),
                            a(str("port-mirror-instance"), arg),
                            a(str("next-hop-group"), arg),
                            str("port-mirror"),
                            str("packet-mode"),
                            str("force-premium"),
                            str("log"),
                            str("syslog"),
                            c(
                              b(str("encapsulate"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline),
                              str("accept"),
                              str("discard"),
                              b(str("next"),
                                (str("term"))
                              )
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:certificate_object) do
      b(arg.as(:arg),
        c(
            arg
        )
      )
    end

    rule(:charging_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            b(str("level"),
              (str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("init") | str("config") | str("general") | str("triggers") | str("cdr-encoding") | str("transport") | str("path-management") | str("fsm") | str("ipc") | str("resource") | str("group-fsm") | str("client-fsm") | str("timers") | str("online") | str("tpm") | str("all"))).as(:oneline)
        )
    end

    rule(:chassis_type) do
        c(
            b(str("copy-tos-to-outer"),
                c(
                    b(str("service-type"),
                        c(
                            str("gre"),
                            str("mt")
                        )
                    )
                )
            ),
            b(str("nssu"),
                c(
                    b(a(str("upgrade-group"), arg),
                        c(
                            a(str("fpcs"), arg),
                            a(str("node-devices"), arg),
                            b(str("member"),
                              upgrade_group_fpcs
                            )
                        )
                    ),
                    a(str("rcp-count"), arg),
                    a(str("lc-reboot-delay"), arg)
                )
            ),
            b(str("psu"),
                c(
                    b(str("redundancy"),
                        c(
                            str("n-plus-n")
                        )
                    )
                )
            ),
            str("fpc-resync"),
            str("craft-lockout"),
            b(str("config-button"),
                sc(
                    str("no-rescue"),
                    str("no-clear")
                )
            ).as(:oneline),
            str("routing-engine-power-off-button-disable"),
            str("source-route"),
            str("no-source-route"),
            str("packet-scheduling"),
            str("no-packet-scheduling"),
            str("route-memory-enhanced"),
            str("policer-drop-probability-low"),
            str("policer-limit"),
            str("enhanced-policer"),
            str("effective-shaping-rate"),
            b(str("memory-enhanced"),
                c(
                    str("route"),
                    str("filter"),
                    str("vpn-label")
                )
            ),
            str("vrf-mtu-check"),
            b(str("icmp"),
                c(
                    a(str("rate-limit"), arg),
                    a(str("per-iff-rate-limit"), arg)
                )
            ),
            str("routing-performance"),
            b(str("icmp6"),
                c(
                    a(str("rate-limit"), arg),
                    a(str("per-iff-rate-limit"), arg)
                )
            ),
            b(str("maximum-ecmp"),
              (str("16") | str("32") | str("64") | str("96") | str("128") | str("160") | str("192") | str("224") | str("256") | str("288") | str("320") | str("352") | str("384") | str("416") | str("448") | str("480") | str("512"))
            ),
            b(str("ecmp-alb"),
                c(
                    a(str("tolerance"), arg)
                )
            ),
            b(str("redundancy"),
              chassis_redundancy_type
            ),
            b(str("routing-engine"),
              chassis_routing_engine_type
            ),
            b(str("aggregated-devices"),
              chassis_agg_dev_type
            ),
            a(str("disk-partition"), enum(str("/var") | str("/config")),
                c(
                    a(str("level"), enum(str("high") | str("full")),
                        c(
                            b(str("free-space"),
                                sc(
                                      arg,
                                    c(
                                      str("percent"),
                                      str("mb")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("container-devices"),
              chassisd_agg_container_type
            ),
            b(str("pseudowire-service"),
              chassis_pw_type
            ),
            b(str("provider-instance-devices"),
              chassisd_provider_instance_type
            ),
            b(str("redundancy-group"),
              chassisd_redundancy_group_type
            ),
            b(str("fabric"),
              chassis_fabric_type
            ),
            b(str("fpc"),
              chassis_fpc_type
            ),
            str("disable-fm"),
            str("disable-power-management"),
            str("monitor-pem-inputs"),
            str("dedicated-ukern-cpu"),
            str("realtime-ukern-thread"),
            b(str("fpc-feb-connectivity"),
                c(
                    b(a(str("fpc"), arg),
                        c(
                            b(str("feb"),
                                sc(
                                    c(
                                      str("none"),
                                        arg
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("ioc-npc-connectivity"),
                c(
                    b(a(str("ioc"), arg),
                        c(
                            b(str("npc"),
                                sc(
                                    c(
                                      str("none"),
                                        arg
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("pem"),
              chassis_pem_type
            ),
            b(str("sib"),
              chassis_sib_type
            ),
            b(str("sfm"),
              chassis_sfm_type
            ),
            b(str("feb"),
              chassis_feb_type
            ),
            b(str("afeb"),
              chassis_feb_type
            ),
            b(str("tfeb"),
              chassis_feb_type
            ),
            b(str("alarm"),
              chassis_alarm_type
            ),
            str("slow-pfe-alarm"),
            b(str("onbox-av-load-flavor"),
              (str("heavy"))
            ),
            str("fpc-ifl-ae-statistics"),
            b(str("ppp-subscriber-services"),
              (str("disable") | str("enable"))
            ),
            b(str("ambient-temperature"),
              (str("55C") | str("40C") | str("25C"))
            ),
            b(str("network-services"),
              (str("ip") | str("ethernet") | str("enhanced-ip") | str("enhanced-ethernet") | str("enhanced-mode") | str("lan"))
            ),
            str("limited-ifl-scaling"),
            b(str("usb"),
                c(
                    b(str("storage"),
                        c(
                            str("disable")
                        )
                    )
                )
            ),
            b(str("serdes"),
                c(
                    a(str("test-mode"), arg)
                )
            ),
            b(a(str("lcc"), arg),
                c(
                    b(str("fpc"),
                      chassis_fpc_type
                    ),
                    b(str("pem"),
                      chassis_pem_type
                    ),
                    str("spmb"),
                    c(
                      str("online-expected"),
                      str("offline")
                    )
                )
            ),
            b(str("lcc-mode"),
                c(
                    b(a(str("lcc"), arg),
                        c(
                            b(str("mode"),
                              (str("t1600") | str("t4000") | str("empty"))
                            )
                        )
                    )
                )
            ),
            b(a(str("member"), arg),
                c(
                    b(str("fabric"),
                      chassis_fabric_type
                    ),
                    b(str("fpc"),
                      chassis_fpc_type
                    )
                )
            ),
            b(str("license"),
                c(
                    a(str("bandwidth"), arg),
                    b(str("scale"),
                      (str("base") | str("advance") | str("premium"))
                    )
                )
            ),
            b(str("host-outbound"),
                c(
                    str("media-interface")
                )
            ),
            b(str("synchronization"),
                c(
                    b(str("switchover-mode"),
                      (str("non-revertive") | str("revertive"))
                    ),
                    b(str("switching-mode"),
                      (str("non-revertive") | str("revertive"))
                    ),
                    b(str("network-option"),
                      (str("option-1") | str("option-2"))
                    ),
                    b(str("selection-mode"),
                      (str("configured-quality") | str("received-quality"))
                    ),
                    b(str("clock-mode"),
                      (str("free-run") | str("auto-select"))
                    ),
                    str("quality-mode-enable"),
                    b(str("max-transmit-quality-level"),
                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("stu") | str("st2") | str("tnc") | str("st3e"))
                    ),
                    a(str("global-wait-to-restore"), arg),
                    a(str("port"), str("auxiliary") | str("gnss") | str("time-of-day"),
                        c(
                            b(str("client"),
                                c(
                                    b(str("time-of-day-format"),
                                        c(
                                            c(
                                              a(str("ascii"), arg)
                                            )
                                        )
                                    ),
                                    a(str("cable-length-compensation"), arg),
                                    b(str("antenna-voltage"),
                                      (str("3.3") | str("5"))
                                    ),
                                    b(str("constellation"),
                                      (str("gps") | str("glonass") | str("gps-and-glonass"))
                                    ),
                                    str("anti-jamming")
                                )
                            ),
                            b(str("server"),
                                c(
                                    b(str("time-of-day-format"),
                                        c(
                                            c(
                                              a(str("ascii"), arg)
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("interfaces"), str("external") | str("external-0/0") | str("external-0/1") | str("external-1/0") | str("external-1/1") | str("external-a") | str("external-b") | str("external-0") | str("external-1") | str("external-2") | str("bits") | str("bits-a") | str("bits-b") | str("gps-0") | str("gps-1"),
                        c(
                            b(str("signal-type"),
                              (str("1mhz") | str("5mhz") | str("10mhz") | str("2048khz") | str("e1") | str("t1") | str("cc-8k") | str("cc-8k-400") | str("6312k"))
                            ),
                            str("pulse-per-second-enable"),
                            b(str("e1-options"),
                                c(
                                    b(str("line-encoding"),
                                      (str("ami") | str("hdb3"))
                                    ),
                                    b(str("framing"),
                                      (str("g704") | str("g704-no-crc4"))
                                    ),
                                    a(str("sabit"), arg)
                                )
                            ),
                            b(str("t1-options"),
                                c(
                                    b(str("line-encoding"),
                                      (str("ami") | str("b8zs"))
                                    ),
                                    b(str("framing"),
                                      (str("esf") | str("sf"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("output"),
                        c(
                            a(str("interfaces"), str("external") | str("external-0/0") | str("external-0/1") | str("external-1/0") | str("external-1/1") | str("external-a") | str("external-b") | str("external-0") | str("external-1") | str("external-2"),
                                c(
                                    str("wander-filter-disable"),
                                    str("holdover-mode-disable"),
                                    b(str("source-mode"),
                                      (str("chassis") | str("line"))
                                    ),
                                    str("tx-dnu-to-line-source-enable"),
                                    b(str("minimum-quality"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("source"),
                        c(
                            b(str("external-a"),
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            ),
                            b(str("external-b"),
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            ),
                            b(str("gps"),
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    str("no-ssm-support"),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            ),
                            b(str("gps-0"),
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    a(str("wait-to-restore"), arg),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            ),
                            b(str("gps-1"),
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    a(str("wait-to-restore"), arg),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            ),
                            b(str("bits"),
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    str("no-ssm-support"),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            ),
                            b(str("bits-a"),
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    a(str("wait-to-restore"), arg),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            ),
                            b(str("bits-b"),
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    a(str("wait-to-restore"), arg),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            ),
                            a(str("interfaces"), str("external") | str("external-0/0") | str("external-0/1") | str("external-1/0") | str("external-1/1") | str("external-a") | str("external-b") | str("external-0") | str("external-1") | str("external-2") | arg,
                                c(
                                    a(str("priority"), arg),
                                    b(str("request"),
                                      (str("lockout") | str("force-switch"))
                                    ),
                                    a(str("wait-to-restore"), arg),
                                    str("no-ssm-support"),
                                    a(str("hold-off-time"), arg),
                                    a(str("aggregated-ether"), arg),
                                    b(str("quality-level"),
                                      (str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("esmc-transmit"),
                        c(
                            a(str("interfaces"), str("all") | arg)
                        )
                    ),
                    b(str("hold-interval"),
                        c(
                            a(str("switchover"), arg),
                            a(str("configuration-change"), arg),
                            a(str("restart"), arg)
                        )
                    ),
                    a(str("validation-interval"), arg),
                    str("slave-free-run"),
                    str("y-cable-line-termination"),
                    str("transmitter-enable"),
                    b(str("signal-type"),
                      (str("e1") | str("t1") | str("cc-8k") | str("cc-8k-400") | str("6312k"))
                    ),
                    b(str("primary"),
                      (str("external-a") | str("external-b") | str("bits-a") | str("bits-b") | str("gps-0") | str("gps-1") | str("fpc-0") | str("fpc-1") | str("fpc-2") | str("fpc-3") | str("fpc-4") | str("fpc-5") | str("fpc-6") | str("fpc-7") | str("fpc-8") | str("fpc-9") | str("fpc-10") | str("fpc-11") | str("fpc-12") | str("fpc-13") | str("fpc-14") | str("fpc-15"))
                    ),
                    b(str("secondary"),
                      (str("external-a") | str("external-b") | str("bits-a") | str("bits-b") | str("gps-0") | str("gps-1") | str("fpc-0") | str("fpc-1") | str("fpc-2") | str("fpc-3") | str("fpc-4") | str("fpc-5") | str("fpc-6") | str("fpc-7") | str("fpc-8") | str("fpc-9") | str("fpc-10") | str("fpc-11") | str("fpc-12") | str("fpc-13") | str("fpc-14") | str("fpc-15"))
                    )
                )
            ),
            b(str("lcd"),
                c(
                    b(a(str("fpc"), arg),
                        sc(
                            c(
                              str("maintenance-menu")
                            ),
                              (str("disable"))
                        )
                    ).as(:oneline),
                    c(
                      str("maintenance-menu")
                    ),
                      (str("disable"))
                )
            ),
            b(str("forwarding-options"),
                c(
                    c(
                      b(str("l2-profile-one"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("l2-profile-two"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("l2-profile-three"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("l3-profile"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("lpm-profile"),
                          c(
                              str("prefix-65-127-disable"),
                              str("unicast-in-lpm")
                          )
                      ),
                      b(str("exact-match-profile"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("custom-profile"),
                          c(
                              b(str("l2-entries"),
                                  c(
                                      a(str("num-banks"), arg)
                                  )
                              ),
                              b(str("l3-entries"),
                                  c(
                                      a(str("num-banks"), arg)
                                  )
                              ),
                              b(str("exact-match-entries"),
                                  c(
                                      a(str("num-banks"), arg)
                                  )
                              ),
                              b(str("lpm-entries"),
                                  c(
                                      b(str("num-banks"),
                                        (str("0") | str("2") | str("4"))
                                      ),
                                      str("prefix-65-127-disable")
                                  )
                              ),
                              a(str("num-65-127-prefix"), arg)
                          )
                      )
                    )
                )
            ),
            str("loopback-firewall-optimization"),
            b(str("lcd-menu"),
                c(
                    b(a(str("fpc"), arg),
                        c(
                            b(a(str("menu-item"), arg),
                                sc(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("menu-item"), arg),
                        sc(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("fru-poweron-sequence"), arg),
            str("fru-local-storage-disable"),
            str("auto-image-upgrade"),
            b(str("route-localization"),
                c(
                    str("inet6"),
                    str("inet")
                )
            ),
            b(str("state"),
                c(
                    b(str("cb-upgrade"),
                      (str("off") | str("on"))
                    ),
                    b(str("sfb-upgrade"),
                      (str("off") | str("on"))
                    )
                )
            ),
            b(str("multicast-loadbalance"),
              chassis_ae_lb_type
            ),
            str("extended-statistics"),
            b(str("error"),
              chassis_fpc_error_type
            ),
            b(str("oss-map"),
                c(
                    b(str("model-name"),
                      (str("t640") | str("t1600"))
                    )
                )
            ),
            a(str("satellite"), arg),
            str("preserve-fpc-poweron-sequence"),
            str("auto-satellite-conversion"),
            b(str("satellite-management"),
                c(
                    str("designated-event-forwarding"),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("parse") | str("config-internal") | str("normal") | str("general") | str("state") | str("task") | str("timer") | str("krt") | str("lldp") | str("provision") | str("extended-port") | str("multi-chassis") | str("upgrade-group") | str("device") | str("tcp") | str("interface") | str("cluster") | str("all")),
                                sc(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("cluster-policy"), arg),
                    b(a(str("cluster"), arg),
                        c(
                            a(str("cluster-id"), arg),
                            b(str("cascade-ports"),
                              interface_device
                            ),
                            a(str("cluster-policy"), arg),
                            b(a(str("fpc"), arg),
                                c(
                                    a(str("alias"), arg),
                                    a(str("description"), quote | arg),
                                    a(str("member-id"), arg),
                                    b(str("system-id"),
                                      mac_addr
                                    ),
                                    a(str("cluster-policy"), arg)
                                )
                            )
                        )
                    ),
                    b(a(str("fpc"), arg),
                        c(
                            a(str("serial-number"), arg),
                            b(str("system-id"),
                              mac_addr
                            ),
                            str("target-mode"),
                            a(str("alias"), arg),
                            a(str("description"), quote | arg),
                            b(str("management-address"),
                                c(
                                    b(str("address"),
                                      ipv4prefix
                                    ),
                                    b(str("gateway"),
                                      ipv4addr
                                    )
                                )
                            ),
                            b(str("cascade-ports"),
                              interface_device
                            ),
                            a(str("extended-ports-template"), arg),
                            c(
                              b(str("uplink-failure-detection"),
                                  c(
                                      a(str("candidate-uplink-policy"), arg)
                                  )
                              )
                            ),
                            a(str("environment-monitoring-policy"), arg),
                            c(
                              b(str("forwarding-policy"),
                                  c(
                                      arg
                                  )
                              )
                            )
                        )
                    ),
                    a(str("extended-ports-policy"), arg),
                    c(
                      b(str("uplink-failure-detection"),
                          c(
                              a(str("candidate-uplink-policy"), arg)
                          )
                      )
                    ),
                    b(str("psu"),
                        c(
                            b(str("redundancy"),
                                c(
                                    str("n-plus-n")
                                )
                            )
                        )
                    ),
                    b(str("environment-monitoring-policy"),
                        c(
                            a(str("policy-name"), arg)
                        )
                    ),
                    c(
                      b(str("forwarding-policy"),
                          c(
                              arg
                          )
                      )
                    ),
                    b(str("redundancy-groups"),
                        c(
                            a(str("chassis-id"), arg),
                              redundancy_group_type
                        )
                    ),
                    b(str("upgrade-groups"),
                        c(
                              upgrade_group_type
                        )
                    ),
                    b(str("auto-satellite-conversion"),
                        c(
                            a(str("satellite"), arg)
                        )
                    ),
                    b(str("single-home"),
                        c(
                            a(str("satellite"), arg)
                        )
                    ),
                    a(str("aging-timer"), arg),
                    str("block-console-access"),
                    b(str("firewall"),
                        c(
                            b(str("family"),
                                c(
                                    b(str("bridge"),
                                        c(
                                            b(str("filter"),
                                              satellite_bridge_filter
                                            )
                                        )
                                    ),
                                    b(str("ethernet-switching"),
                                        c(
                                            b(str("filter"),
                                              satellite_bridge_filter
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("periodic"),
                c(
                    str("yield-cpu"),
                    str("one-sib-per-check"),
                    str("no-sib-asic-stats"),
                    str("slow-fpc-check"),
                    a(str("ch-power-check-interval"), arg),
                    a(str("re-check-interval"), arg)
                )
            ),
            str("turbotx-disable"),
            str("thermal-health-check"),
            b(str("fpc-down-on-repeated-conn-drops"),
                c(
                    a(str("max-drop-count"), arg),
                    a(str("time-interval"), arg)
                )
            ),
            b(str("mode"),
                c(
                    b(str("standalone"),
                        c(
                            b(a(str("fpc"), arg),
                                c(
                                    b(str("loopback"),
                                        c(
                                            b(str("wan"),
                                              (str("serdes") | str("retimer"))
                                            ),
                                            b(str("fabric"),
                                              (str("serdes") | str("retimer"))
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("fabric-card"),
                              chassis_fabric_card_type
                            )
                        )
                    )
                )
            ),
            b(str("system-domains"),
                c(
                    a(str("root-domain-id"), arg),
                    b(str("protected-system-domains"),
                      juniper_protected_system_domain
                    ),
                    b(str("traceoptions"),
                      juniper_protected_system_domain_traceoptions
                    )
                )
            ),
            b(str("network-slices"),
                c(
                    b(str("guest-network-functions"),
                        c(
                            b(str("gnf"),
                              juniper_gnf
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:chassis_pw_type) do
        c(
            a(str("device-count"), arg)
        )
    end

    rule(:chassis_ae_lb_type) do
        c(
            str("disable"),
            b(str("hash-mode"),
              (str("crc-sgip") | str("crc-gip") | str("crc-sip") | str("simple-sgip") | str("simple-gip") | str("simple-sip") | str("balanced"))
            )
        )
    end

    rule(:chassis_agg_dev_type) do
        c(
            str("ae-20"),
            b(str("ethernet"),
              chassisd_agg_enet_type
            ),
            b(str("sonet"),
              chassisd_agg_pos_type
            ),
            a(str("maximum-links"), arg)
        )
    end

    rule(:chassis_alarm_type) do
        c(
            b(str("management-ethernet"),
              chassis_alarm_ethernet_type
            ),
            b(str("otn-odu"),
              chassis_alarm_otn_odu_type
            ),
            b(str("otn-otu"),
              chassis_alarm_otn_otu_type
            ),
            b(str("sonet"),
              chassis_alarm_sonet_type
            ),
            b(str("t3"),
              chassis_alarm_ds3_type
            ),
            b(str("ds1"),
              chassis_alarm_ds1_type
            ),
            b(str("ethernet"),
              chassis_alarm_ethernet_type
            ),
            b(str("integrated-services"),
              chassis_alarm_integrated_services_type
            ),
            b(str("services"),
              chassis_alarm_services_type
            ),
            b(str("serial"),
              chassis_alarm_serial_type
            ),
            b(str("fibre-channel"),
              chassis_alarm_fibre_channel_type
            ),
            b(str("relay"),
              chassis_alarm_relay_type
            )
        )
    end

    rule(:chassis_alarm_ds1_type) do
        c(
            b(str("ais"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("ylw"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_ds3_type) do
        c(
            b(str("ais"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("exz"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("ferf"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("idle"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("lcv"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("lof"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("los"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("pll"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("ylw"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_ethernet_type) do
        c(
            b(str("link-down"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_fibre_channel_type) do
        c(
            b(str("link-down"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_integrated_services_type) do
        c(
            b(str("failure"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_otn_odu_type) do
        c(
            b(str("odu-bdi"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("odu-ttim"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("odu-ptim"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_otn_otu_type) do
        c(
            b(str("oc-los"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("oc-lof"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("oc-lom"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("wavelength-lock"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("otu-bdi"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("otu-iae"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("otu-ttim"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("otu-fec-excessive-errs"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_relay_type) do
        c(
            b(str("input"),
                c(
                    b(a(str("port"), arg),
                        c(
                            b(str("mode"),
                              (str("open") | str("close"))
                            ),
                            b(str("trigger"),
                              (str("red") | str("yellow") | str("ignore"))
                            )
                        )
                    )
                )
            ),
            b(str("output"),
                c(
                    b(a(str("port"), arg),
                        c(
                            b(str("mode"),
                              (str("open") | str("close"))
                            ),
                            str("temperature"),
                            a(str("input-relay"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:chassis_alarm_serial_type) do
        c(
            b(str("loss-of-rx-clock"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("loss-of-tx-clock"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("dcd-absent"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("cts-absent"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("dsr-absent"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("tm-absent"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_services_type) do
        c(
            b(str("pic-reset"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("pic-hold-reset"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("linkdown"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("rx-errors"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("tx-errors"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("sw-down"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("hw-down"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_alarm_sonet_type) do
        c(
            b(str("lol"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("pll"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("lof"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("los"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("ais-l"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("ais-p"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("lop-p"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("ber-sd"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("ber-sf"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("rfi-l"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("rfi-p"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("uneq-p"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("locd"),
              (str("red") | str("yellow") | str("ignore"))
            ),
            b(str("plm-p"),
              (str("red") | str("yellow") | str("ignore"))
            )
        )
    end

    rule(:chassis_fabric_card_type) do
      b(arg.as(:arg),
        c(
            b(str("loopback"),
                c(
                    str("serdes"),
                    str("retimer")
                )
            )
        )
      )
    end

    rule(:chassis_fabric_type) do
        c(
            b(str("upgrade-mode"),
              (str("default") | str("t4000") | str("3d-fabric"))
            ),
            str("blackhole"),
            b(str("degraded"),
                c(
                    str("action-fpc-restart-disable"),
                    a(str("degraded-fpc-bad-plane-threshold"), arg),
                    str("degraded-fabric-detection-enable"),
                    str("fpc-restart"),
                    str("auto-recovery-disable"),
                    str("fpc-offline-on-blackholing")
                )
            ),
            b(str("redundancy-mode"),
                c(
                    c(
                      str("redundant"),
                      str("increased-bandwidth")
                    )
                )
            ),
            str("disable-grant-bypass")
        )
    end

    rule(:chassis_feb_type) do
        c(
            b(str("sanity-poll"),
                c(
                    a(str("retry-count"), arg),
                    b(str("on-error"),
                        c(
                            str("raise-alarm"),
                            b(str("power"),
                              (str("cycle") | str("off"))
                            ),
                            str("write-coredump")
                        )
                    )
                )
            ),
            b(a(str("slot"), arg),
                c(
                    b(str("sanity-poll"),
                        c(
                            a(str("retry-count"), arg),
                            b(str("on-error"),
                                c(
                                    str("raise-alarm"),
                                    b(str("power"),
                                      (str("cycle") | str("off"))
                                    ),
                                    str("write-coredump")
                                )
                            )
                        )
                    ),
                    b(str("power"),
                      (str("off") | str("on"))
                    ),
                    a(str("port-mirror-instance"), arg),
                    a(str("sampling-instance"), arg),
                    str("ucode-imem-remap"),
                    b(str("inline-services"),
                        c(
                            str("report-zero-oif-gw-on-discard"),
                            str("flex-flow-sizing"),
                            str("use-extended-flow-memory"),
                            b(str("flow-table-size"),
                                c(
                                    a(str("ipv4-flow-table-size"), arg),
                                    a(str("ipv6-flow-table-size"), arg),
                                    a(str("vpls-flow-table-size"), arg),
                                    a(str("bridge-flow-table-size"), arg),
                                    str("ipv6-extended-attrib"),
                                    a(str("mpls-flow-table-size"), arg)
                                )
                            )
                        )
                    ),
                    b(str("inline-video-monitoring"),
                        c(
                            a(str("maximum-flows-count"), arg)
                        )
                    ),
                    b(str("openflow"),
                        c(
                            a(str("access-list-partition"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:chassis_fpc_error_type) do
        c(
            b(str("fatal"),
              chassis_fpc_error_level_major_fatal
            ),
            b(str("major"),
              chassis_fpc_error_level_major_fatal
            ),
            b(str("minor"),
              chassis_fpc_error_level_minor
            ),
              chassis_fru_cmerror_override_type,
            b(str("scope"),
              chassis_fpc_scope_type
            )
        )
    end

    rule(:chassis_fpc_error_level_major_fatal) do
        c(
            a(str("threshold"), arg),
            a(str("action"), enum(str("reset") | str("offline") | str("alarm") | str("get-state") | str("log") | str("disable-pfe") | str("offline-pic") | str("trap")))
        )
    end

    rule(:chassis_fpc_error_level_minor) do
        c(
            a(str("threshold"), arg),
            a(str("action"), enum(str("reset") | str("offline") | str("alarm") | str("get-state") | str("log") | str("disable-pfe") | str("offline-pic") | str("trap")))
        )
    end

    rule(:chassis_fpc_scope_type) do
        c(
            b(str("board"),
              chassis_fpc_scope_category
            ),
            b(str("pfe"),
              chassis_fpc_scope_category
            )
        )
    end

    rule(:chassis_fpc_scope_category) do
        c(
            b(str("category"),
              chassis_fpc_scope_category_type
            )
        )
    end

    rule(:chassis_fpc_scope_category_type) do
        c(
            b(str("functional"),
              chassis_fpc_scope_category_error_type
            ),
            b(str("memory"),
              chassis_fpc_scope_category_error_type
            ),
            b(str("io"),
              chassis_fpc_scope_category_error_type
            ),
            b(str("storage"),
              chassis_fpc_scope_category_error_type
            ),
            b(str("switch"),
              chassis_fpc_scope_category_error_type
            ),
            b(str("processing"),
              chassis_fpc_scope_category_error_type
            )
        )
    end

    rule(:chassis_fpc_scope_category_error_type) do
        c(
            b(str("fatal"),
              chassis_fpc_error_level_type
            ),
            b(str("major"),
              chassis_fpc_error_level_type
            ),
            b(str("minor"),
              chassis_fpc_error_level_type
            )
        )
    end

    rule(:chassis_fpc_error_level_type) do
        c(
            a(str("threshold"), arg),
            a(str("action"), enum(str("reset") | str("offline") | str("alarm") | str("get-state") | str("log") | str("disable-pfe") | str("offline-pic") | str("trap")))
        )
    end

    rule(:chassis_fpc_type) do
      b(arg.as(:arg),
        c(
            b(str("auto-speed-detection"),
                c(
                    c(
                      str("disable")
                    )
                )
            ),
            b(str("ukern-trace"),
                c(
                    b(str("log"),
                        c(
                            b(str("app-type"),
                              (str("dfw"))
                            ),
                            b(str("logging"),
                              (str("off") | str("on"))
                            )
                        )
                    )
                )
            ),
            b(str("sanity-poll"),
                c(
                    a(str("retry-count"), arg),
                    b(str("on-error"),
                        c(
                            str("raise-alarm"),
                            b(str("power"),
                              (str("cycle") | str("off"))
                            ),
                            str("write-coredump")
                        )
                    )
                )
            ),
            b(str("forwarding-options"),
                c(
                    c(
                      b(str("l2-profile-one"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("l2-profile-two"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("l2-profile-three"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("l3-profile"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("lpm-profile"),
                          c(
                              str("prefix-65-127-disable"),
                              str("unicast-in-lpm")
                          )
                      ),
                      b(str("exact-match-profile"),
                          c(
                              a(str("num-65-127-prefix"), arg)
                          )
                      ),
                      b(str("custom-profile"),
                          c(
                              b(str("l2-entries"),
                                  c(
                                      a(str("num-banks"), arg)
                                  )
                              ),
                              b(str("l3-entries"),
                                  c(
                                      a(str("num-banks"), arg)
                                  )
                              ),
                              b(str("exact-match-entries"),
                                  c(
                                      a(str("num-banks"), arg)
                                  )
                              ),
                              b(str("lpm-entries"),
                                  c(
                                      b(str("num-banks"),
                                        (str("0") | str("2") | str("4"))
                                      ),
                                      str("prefix-65-127-disable")
                                  )
                              ),
                              a(str("num-65-127-prefix"), arg)
                          )
                      )
                    )
                )
            ),
            b(str("pic"),
              chassis_pic_type
            ),
            b(str("optical-options"),
                c(
                    str("disable-edfa"),
                    str("no-disable-edfa"),
                    str("disable-osc"),
                    str("no-disable-osc"),
                    a(str("wavelength"), str("1568.77") | str("1568.36") | str("1568.31") | str("1568.26") | str("1568.21") | str("1568.16") | str("1568.11") | str("1568.05") | str("1568.00") | str("1567.95") | str("1567.90") | str("1567.85") | str("1567.80") | str("1567.75") | str("1567.70") | str("1567.64") | str("1567.59") | str("1567.54") | str("1567.49") | str("1567.44") | str("1567.39") | str("1567.34") | str("1567.29") | str("1567.23") | str("1567.18") | str("1567.13") | str("1567.08") | str("1567.03") | str("1566.98") | str("1566.93") | str("1566.88") | str("1566.83") | str("1566.77") | str("1566.72") | str("1566.67") | str("1566.62") | str("1566.57") | str("1566.52") | str("1566.47") | str("1566.42") | str("1566.36") | str("1566.31") | str("1566.26") | str("1566.21") | str("1566.16") | str("1566.11") | str("1566.06") | str("1566.01") | str("1565.96") | str("1565.90") | str("1565.85") | str("1565.80") | str("1565.75") | str("1565.70") | str("1565.65") | str("1565.60") | str("1565.55") | str("1565.50") | str("1565.44") | str("1565.39") | str("1565.34") | str("1565.29") | str("1565.24") | str("1565.19") | str("1565.14") | str("1565.09") | str("1565.04") | str("1564.99") | str("1564.93") | str("1564.88") | str("1564.83") | str("1564.78") | str("1564.73") | str("1564.68") | str("1564.63") | str("1564.58") | str("1564.53") | str("1564.47") | str("1564.42") | str("1564.37") | str("1564.32") | str("1564.27") | str("1564.22") | str("1564.17") | str("1564.12") | str("1564.07") | str("1564.02") | str("1563.96") | str("1563.91") | str("1563.86") | str("1563.81") | str("1563.76") | str("1563.71") | str("1563.66") | str("1563.61") | str("1563.56") | str("1563.51") | str("1563.45") | str("1563.40") | str("1563.35") | str("1563.30") | str("1563.25") | str("1563.20") | str("1563.15") | str("1563.10") | str("1563.05") | str("1563.00") | str("1562.95") | str("1562.89") | str("1562.84") | str("1562.79") | str("1562.74") | str("1562.69") | str("1562.64") | str("1562.59") | str("1562.54") | str("1562.49") | str("1562.44") | str("1562.39") | str("1562.33") | str("1562.28") | str("1562.23") | str("1562.18") | str("1562.13") | str("1562.08") | str("1562.03") | str("1561.98") | str("1561.93") | str("1561.88") | str("1561.83") | str("1561.77") | str("1561.72") | str("1561.67") | str("1561.62") | str("1561.57") | str("1561.52") | str("1561.47") | str("1561.42") | str("1561.37") | str("1561.32") | str("1561.27") | str("1561.22") | str("1561.16") | str("1561.11") | str("1561.06") | str("1561.01") | str("1560.96") | str("1560.91") | str("1560.86") | str("1560.81") | str("1560.76") | str("1560.71") | str("1560.66") | str("1560.61") | str("1560.56") | str("1560.50") | str("1560.45") | str("1560.40") | str("1560.35") | str("1560.30") | str("1560.25") | str("1560.20") | str("1560.15") | str("1560.10") | str("1560.05") | str("1560.00") | str("1559.95") | str("1559.90") | str("1559.84") | str("1559.79") | str("1559.74") | str("1559.69") | str("1559.64") | str("1559.59") | str("1559.54") | str("1559.49") | str("1559.44") | str("1559.39") | str("1559.34") | str("1559.29") | str("1559.24") | str("1559.19") | str("1559.14") | str("1559.08") | str("1559.03") | str("1558.98") | str("1558.93") | str("1558.88") | str("1558.83") | str("1558.78") | str("1558.73") | str("1558.68") | str("1558.63") | str("1558.58") | str("1558.53") | str("1558.48") | str("1558.43") | str("1558.38") | str("1558.32") | str("1558.27") | str("1558.22") | str("1558.17") | str("1558.12") | str("1558.07") | str("1558.02") | str("1557.97") | str("1557.92") | str("1557.87") | str("1557.82") | str("1557.77") | str("1557.72") | str("1557.67") | str("1557.62") | str("1557.57") | str("1557.52") | str("1557.46") | str("1557.41") | str("1557.36") | str("1557.31") | str("1557.26") | str("1557.21") | str("1557.16") | str("1557.11") | str("1557.06") | str("1557.01") | str("1556.96") | str("1556.91") | str("1556.86") | str("1556.81") | str("1556.76") | str("1556.71") | str("1556.66") | str("1556.61") | str("1556.55") | str("1556.50") | str("1556.45") | str("1556.40") | str("1556.35") | str("1556.30") | str("1556.25") | str("1556.20") | str("1556.15") | str("1556.10") | str("1556.05") | str("1556.00") | str("1555.95") | str("1555.90") | str("1555.85") | str("1555.80") | str("1555.75") | str("1555.70") | str("1555.65") | str("1555.60") | str("1555.55") | str("1555.49") | str("1555.44") | str("1555.39") | str("1555.34") | str("1555.29") | str("1555.24") | str("1555.19") | str("1555.14") | str("1555.09") | str("1555.04") | str("1554.99") | str("1554.94") | str("1554.89") | str("1554.84") | str("1554.79") | str("1554.74") | str("1554.69") | str("1554.64") | str("1554.59") | str("1554.54") | str("1554.49") | str("1554.44") | str("1554.39") | str("1554.34") | str("1554.29") | str("1554.23") | str("1554.18") | str("1554.13") | str("1554.08") | str("1554.03") | str("1553.98") | str("1553.93") | str("1553.88") | str("1553.83") | str("1553.78") | str("1553.73") | str("1553.68") | str("1553.63") | str("1553.58") | str("1553.53") | str("1553.48") | str("1553.43") | str("1553.38") | str("1553.33") | str("1553.28") | str("1553.23") | str("1553.18") | str("1553.13") | str("1553.08") | str("1553.03") | str("1552.98") | str("1552.93") | str("1552.88") | str("1552.83") | str("1552.78") | str("1552.73") | str("1552.68") | str("1552.62") | str("1552.57") | str("1552.52") | str("1552.47") | str("1552.42") | str("1552.37") | str("1552.32") | str("1552.27") | str("1552.22") | str("1552.17") | str("1552.12") | str("1552.07") | str("1552.02") | str("1551.97") | str("1551.92") | str("1551.87") | str("1551.82") | str("1551.77") | str("1551.72") | str("1551.67") | str("1551.62") | str("1551.57") | str("1551.52") | str("1551.47") | str("1551.42") | str("1551.37") | str("1551.32") | str("1551.27") | str("1551.22") | str("1551.17") | str("1551.12") | str("1551.07") | str("1551.02") | str("1550.97") | str("1550.92") | str("1550.87") | str("1550.82") | str("1550.77") | str("1550.72") | str("1550.67") | str("1550.62") | str("1550.57") | str("1550.52") | str("1550.47") | str("1550.42") | str("1550.37") | str("1550.32") | str("1550.27") | str("1550.22") | str("1550.17") | str("1550.12") | str("1550.07") | str("1550.02") | str("1549.97") | str("1549.92") | str("1549.87") | str("1549.82") | str("1549.77") | str("1549.72") | str("1549.67") | str("1549.62") | str("1549.57") | str("1549.52") | str("1549.47") | str("1549.42") | str("1549.37") | str("1549.32") | str("1549.26") | str("1549.21") | str("1549.16") | str("1549.11") | str("1549.06") | str("1549.01") | str("1548.96") | str("1548.91") | str("1548.86") | str("1548.81") | str("1548.76") | str("1548.71") | str("1548.66") | str("1548.61") | str("1548.56") | str("1548.51") | str("1548.46") | str("1548.41") | str("1548.36") | str("1548.31") | str("1548.26") | str("1548.21") | str("1548.16") | str("1548.11") | str("1548.06") | str("1548.02") | str("1547.97") | str("1547.92") | str("1547.87") | str("1547.82") | str("1547.77") | str("1547.72") | str("1547.67") | str("1547.62") | str("1547.57") | str("1547.52") | str("1547.47") | str("1547.42") | str("1547.37") | str("1547.32") | str("1547.27") | str("1547.22") | str("1547.17") | str("1547.12") | str("1547.07") | str("1547.02") | str("1546.97") | str("1546.92") | str("1546.87") | str("1546.82") | str("1546.77") | str("1546.72") | str("1546.67") | str("1546.62") | str("1546.57") | str("1546.52") | str("1546.47") | str("1546.42") | str("1546.37") | str("1546.32") | str("1546.27") | str("1546.22") | str("1546.17") | str("1546.12") | str("1546.07") | str("1546.02") | str("1545.97") | str("1545.92") | str("1545.87") | str("1545.82") | str("1545.77") | str("1545.72") | str("1545.67") | str("1545.62") | str("1545.57") | str("1545.52") | str("1545.47") | str("1545.42") | str("1545.37") | str("1545.32") | str("1545.27") | str("1545.22") | str("1545.17") | str("1545.12") | str("1545.07") | str("1545.02") | str("1544.97") | str("1544.92") | str("1544.87") | str("1544.82") | str("1544.77") | str("1544.72") | str("1544.68") | str("1544.63") | str("1544.58") | str("1544.53") | str("1544.48") | str("1544.43") | str("1544.38") | str("1544.33") | str("1544.28") | str("1544.23") | str("1544.18") | str("1544.13") | str("1544.08") | str("1544.03") | str("1543.98") | str("1543.93") | str("1543.88") | str("1543.83") | str("1543.78") | str("1543.73") | str("1543.68") | str("1543.63") | str("1543.58") | str("1543.53") | str("1543.48") | str("1543.43") | str("1543.38") | str("1543.33") | str("1543.28") | str("1543.23") | str("1543.18") | str("1543.13") | str("1543.08") | str("1543.04") | str("1542.99") | str("1542.94") | str("1542.89") | str("1542.84") | str("1542.79") | str("1542.74") | str("1542.69") | str("1542.64") | str("1542.59") | str("1542.54") | str("1542.49") | str("1542.44") | str("1542.39") | str("1542.34") | str("1542.29") | str("1542.24") | str("1542.19") | str("1542.14") | str("1542.09") | str("1542.04") | str("1541.99") | str("1541.94") | str("1541.89") | str("1541.84") | str("1541.80") | str("1541.75") | str("1541.70") | str("1541.65") | str("1541.60") | str("1541.55") | str("1541.50") | str("1541.45") | str("1541.40") | str("1541.35") | str("1541.30") | str("1541.25") | str("1541.20") | str("1541.15") | str("1541.10") | str("1541.05") | str("1541.00") | str("1540.95") | str("1540.90") | str("1540.85") | str("1540.80") | str("1540.76") | str("1540.71") | str("1540.66") | str("1540.61") | str("1540.56") | str("1540.51") | str("1540.46") | str("1540.41") | str("1540.36") | str("1540.31") | str("1540.26") | str("1540.21") | str("1540.16") | str("1540.11") | str("1540.06") | str("1540.01") | str("1539.96") | str("1539.91") | str("1539.86") | str("1539.82") | str("1539.77") | str("1539.72") | str("1539.67") | str("1539.62") | str("1539.57") | str("1539.52") | str("1539.47") | str("1539.42") | str("1539.37") | str("1539.32") | str("1539.27") | str("1539.22") | str("1539.17") | str("1539.12") | str("1539.07") | str("1539.03") | str("1538.98") | str("1538.93") | str("1538.88") | str("1538.83") | str("1538.78") | str("1538.73") | str("1538.68") | str("1538.63") | str("1538.58") | str("1538.53") | str("1538.48") | str("1538.43") | str("1538.38") | str("1538.33") | str("1538.28") | str("1538.24") | str("1538.19") | str("1538.14") | str("1538.09") | str("1538.04") | str("1537.99") | str("1537.94") | str("1537.89") | str("1537.84") | str("1537.79") | str("1537.74") | str("1537.69") | str("1537.64") | str("1537.59") | str("1537.55") | str("1537.50") | str("1537.45") | str("1537.40") | str("1537.35") | str("1537.30") | str("1537.25") | str("1537.20") | str("1537.15") | str("1537.10") | str("1537.05") | str("1537.00") | str("1536.95") | str("1536.90") | str("1536.86") | str("1536.81") | str("1536.76") | str("1536.71") | str("1536.66") | str("1536.61") | str("1536.56") | str("1536.51") | str("1536.46") | str("1536.41") | str("1536.36") | str("1536.31") | str("1536.26") | str("1536.22") | str("1536.17") | str("1536.12") | str("1536.07") | str("1536.02") | str("1535.97") | str("1535.92") | str("1535.87") | str("1535.82") | str("1535.77") | str("1535.72") | str("1535.67") | str("1535.63") | str("1535.58") | str("1535.53") | str("1535.48") | str("1535.43") | str("1535.38") | str("1535.33") | str("1535.28") | str("1535.23") | str("1535.18") | str("1535.13") | str("1535.08") | str("1535.04") | str("1534.99") | str("1534.94") | str("1534.89") | str("1534.84") | str("1534.79") | str("1534.74") | str("1534.69") | str("1534.64") | str("1534.59") | str("1534.54") | str("1534.50") | str("1534.45") | str("1534.40") | str("1534.35") | str("1534.30") | str("1534.25") | str("1534.20") | str("1534.15") | str("1534.10") | str("1534.05") | str("1534.00") | str("1533.96") | str("1533.91") | str("1533.86") | str("1533.81") | str("1533.76") | str("1533.71") | str("1533.66") | str("1533.61") | str("1533.56") | str("1533.51") | str("1533.47") | str("1533.42") | str("1533.37") | str("1533.32") | str("1533.27") | str("1533.22") | str("1533.17") | str("1533.12") | str("1533.07") | str("1533.02") | str("1532.98") | str("1532.93") | str("1532.88") | str("1532.83") | str("1532.78") | str("1532.73") | str("1532.68") | str("1532.63") | str("1532.58") | str("1532.53") | str("1532.49") | str("1532.44") | str("1532.39") | str("1532.34") | str("1532.29") | str("1532.24") | str("1532.19") | str("1532.14") | str("1532.09") | str("1532.04") | str("1532.00") | str("1531.95") | str("1531.90") | str("1531.85") | str("1531.80") | str("1531.75") | str("1531.70") | str("1531.65") | str("1531.60") | str("1531.56") | str("1531.51") | str("1531.46") | str("1531.41") | str("1531.36") | str("1531.31") | str("1531.26") | str("1531.21") | str("1531.16") | str("1531.12") | str("1531.07") | str("1531.02") | str("1530.97") | str("1530.92") | str("1530.87") | str("1530.82") | str("1530.77") | str("1530.72") | str("1530.68") | str("1530.63") | str("1530.58") | str("1530.53") | str("1530.48") | str("1530.43") | str("1530.38") | str("1530.33") | str("1530.29") | str("1530.24") | str("1530.19") | str("1530.14") | str("1530.09") | str("1530.04") | str("1529.99") | str("1529.94") | str("1529.89") | str("1529.85") | str("1529.80") | str("1529.75") | str("1529.70") | str("1529.65") | str("1529.60") | str("1529.55") | str("1529.50") | str("1529.46") | str("1529.41") | str("1529.36") | str("1529.31") | str("1529.26") | str("1529.21") | str("1529.16") | str("1529.11") | str("1529.07") | str("1529.02") | str("1528.97") | str("1528.92") | str("1528.87") | str("1528.82") | str("1528.77") | str("1528.38"),
                        c(
                            c(
                              b(str("switch"),
                                  c(
                                      arg
                                  )
                              ),
                              str("wss-express-in")
                            )
                        )
                    ),
                    b(str("tca"),
                        c(
                            b(str("osc-tx-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("osc-tx-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("osc-rx-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("osc-rx-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("osc-fiber-loss-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("osc-fiber-loss-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("lout-voa-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("lout-voa-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-in-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-in-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-out-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-out-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-sig-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-sig-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-awg-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-awg-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-express-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa1-express-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-in-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-in-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-out-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-out-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-sig-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-sig-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-awg-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-awg-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-express-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("edfa2-express-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("ocm-power-high-line-out-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("ocm-power-low-line-out-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            )
                        )
                    ),
                    b(str("expansion-card"),
                        c(
                            b(str("fpc"),
                                c(
                                      arg
                                )
                            )
                        )
                    ),
                    b(str("express-in"),
                        c(
                            b(str("fpc"),
                                c(
                                      arg
                                )
                            )
                        )
                    ),
                    b(str("amplifier-chain"),
                        c(
                            str("anchor-iplc"),
                            str("no-anchor-iplc"),
                            a(str("osc-ip"), arg),
                            a(str("osc-mac"), arg),
                            b(a(str("ila"), arg),
                                c(
                                    b(str("ila-options"),
                                        c(
                                            a(str("ila-ipv4-address"), arg),
                                            a(str("ila-user"), arg),
                                            b(str("ila-password"),
                                              unreadable
                                            ),
                                            b(str("edfa-a-b"),
                                                c(
                                                    b(str("tca-input-power-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-input-power-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-output-power-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-output-power-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-signal-output-power-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-signal-output-power-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump0-current-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump0-current-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump1-current-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump1-current-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump0-temperature-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump0-temperature-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump1-temperature-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump1-temperature-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("voa-a"),
                                                c(
                                                    b(str("tca-attenuation-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-attenuation-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("osc-a"),
                                                c(
                                                    b(str("osc-tx-power-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-tx-power-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-rx-power-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-rx-power-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-fiber-loss-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-fiber-loss-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("edfa-b-a"),
                                                c(
                                                    b(str("tca-input-power-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-input-power-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-output-power-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-output-power-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-signal-output-power-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-signal-output-power-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump0-current-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump0-current-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump1-current-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump1-current-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump0-temperature-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump0-temperature-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump1-temperature-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-pump1-temperature-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("voa-b"),
                                                c(
                                                    b(str("tca-attenuation-low"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tca-attenuation-high"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("osc-b"),
                                                c(
                                                    b(str("osc-tx-power-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-tx-power-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-rx-power-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-rx-power-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-fiber-loss-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("osc-fiber-loss-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("power"),
              (str("off") | str("on"))
            ),
            b(str("traffic-manager"),
                c(
                    str("buffer-monitor-enable"),
                    b(str("queue-threshold"),
                        c(
                            b(str("fabric-queue"),
                                c(
                                    a(str("priority"), enum(str("low") | str("high")),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("wan-queue"),
                                c(
                                    a(str("priority"), enum(str("low") | str("medium-low") | str("medium-high") | str("high")),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("enhanced-priority-mode"),
                    str("no-enhanced-priority-mode"),
                    b(str("packet-timestamp"),
                      (str("enable") | str("disable"))
                    )
                )
            ),
            b(str("route-localization"),
              (str("fib-remote") | str("fib-local"))
            ),
            b(str("vpn-localization"),
              (str("vpn-core-facing-only") | str("vpn-core-facing-default"))
            ),
            a(str("power-budget-priority"), arg),
            c(
              str("disable-power"),
              str("allow-sram-parity-errors")
            ),
            c(
              b(str("performance-mode"),
                  c(
                      a(str("number-of-ucode-workers"), arg)
                  )
              ),
              str("lite-mode")
            ),
            str("services-offload"),
            str("cfp-to-et"),
            str("np-cache"),
            str("offline"),
            str("offline-on-fabric-bandwidth-reduction"),
            b(str("ir-mode"),
              (str("IR") | str("R"))
            ),
            b(str("license-mode"),
              (str("r") | str("ir") | str("lsr") | str("ip"))
            ),
            b(str("fabric"),
                c(
                    b(str("blackhole-action"),
                      (str("log-only") | str("offline") | str("restart") | str("restart-then-offline"))
                    ),
                    b(str("bandwidth-degradation"),
                        c(
                            a(str("percentage"), arg),
                            str("no-fabric-switchover"),
                            b(str("action"),
                              (str("log-only") | str("offline") | str("restart") | str("restart-then-offline"))
                            )
                        )
                    )
                )
            ),
            a(str("port-mirror-instance"), arg),
            a(str("sampling-instance"), arg),
            b(str("inline-services"),
                c(
                    str("report-zero-oif-gw-on-discard"),
                    str("flex-flow-sizing"),
                    str("use-extended-flow-memory"),
                    b(str("flow-table-size"),
                        c(
                            a(str("ipv4-flow-table-size"), arg),
                            a(str("ipv6-flow-table-size"), arg),
                            a(str("vpls-flow-table-size"), arg),
                            a(str("bridge-flow-table-size"), arg),
                            str("ipv6-extended-attrib"),
                            a(str("mpls-flow-table-size"), arg)
                        )
                    )
                )
            ),
            b(str("inline-video-monitoring"),
                c(
                    a(str("maximum-flows-count"), arg),
                    a(str("flow-table-size"), arg)
                )
            ),
            b(str("application-services"),
                c(
                    a(str("package"), arg)
                )
            ),
            b(str("slamon-services"),
                c(
                    str("rfc2544")
                )
            ),
            str("flexible-queuing-mode"),
            a(str("loopback-device-count"), arg),
            str("interasic-linkerror-recovery-enable"),
            b(str("number-of-ports"),
              (str("8") | str("12"))
            ),
            b(str("pfe"),
              chassis_pfe_type
            ),
            b(str("service-package"),
              (str("bundle-rfc2544") | str("bundle-nat-ipsec") | str("bundle-ptp-enterprise-profile"))
            ),
            b(str("max-queues"),
              (str("8k") | str("16k") | str("32k") | str("48k") | str("64k") | str("96k") | str("128k") | str("192k") | str("256k") | str("384k") | str("512k") | str("768k") | str("1M") | str("1536k") | str("2M"))
            ),
            b(str("bandwidth"),
              (str("1.6T"))
            ),
            b(str("pfe-bandwidth"),
              (str("240G") | str("300G") | str("400G"))
            ),
            b(str("error"),
              chassis_fpc_error_type
            ),
            b(a(str("ether-type"), arg),
                c(
                    arg
                )
            ),
            b(str("openflow"),
                c(
                    a(str("access-list-partition"), arg),
                    a(str("buffer-partition"), arg)
                )
            )
        )
      )
    end

    rule(:chassis_fru_cmerror_override_type) do
      b(arg.as(:arg),
        c(
            b(str("state"),
              (str("disable"))
            ),
            b(str("severity"),
              (str("minor") | str("major") | str("fatal"))
            )
        )
      )
    end

    rule(:chassis_pem_type) do
        c(
            a(str("minimum"), arg),
            a(str("feeds"), arg),
            b(str("input-current"),
              (str("40") | str("60"))
            )
        )
    end

    rule(:chassis_pfe_type) do
      b(arg.as(:arg),
        c(
            b(str("forwarding-packages"),
                c(
                    b(str("mobility"),
                        c(
                            c(
                              str("ggsn-pgw"),
                              str("sgw")
                            )
                        )
                    )
                )
            ),
            b(str("power"),
              (str("off") | str("on"))
            ),
            str("tunnel-services")
        )
      )
    end

    rule(:chassis_pic_type) do
      b(arg.as(:arg),
        c(
            b(str("pic-mode"),
              (str("10G") | str("25G") | str("40G") | str("100G"))
            ),
            b(str("tunnel-port"),
              chassis_port_type
            ),
            b(str("tunnel-services"),
                c(
                    b(str("bandwidth"),
                      (str("1g") | str("10g") | str("20g") | str("30g") | str("40g") | str("50g") | str("60g") | str("70g") | str("80g") | str("90g") | str("100g") | str("200g") | str("300g") | str("400g") | str("480g") | arg)
                    ),
                    str("tunnel-only"),
                    b(str("priority"),
                        c(
                            b(str("high"),
                                c(
                                    b(str("bandwidth"),
                                      (str("1g") | str("10g") | str("20g") | str("30g") | str("40g") | str("50g") | str("60g") | str("70g") | str("80g") | str("90g") | str("100g") | str("200g") | str("300g") | str("400g") | str("480g") | arg)
                                    )
                                )
                            ),
                            b(str("medium"),
                                c(
                                    b(str("bandwidth"),
                                      (str("1g") | str("10g") | str("20g") | str("30g") | str("40g") | str("50g") | str("60g") | str("70g") | str("80g") | str("90g") | str("100g") | str("200g") | str("300g") | str("400g") | str("480g") | arg)
                                    )
                                )
                            ),
                            b(str("low"),
                                c(
                                    b(str("bandwidth"),
                                      (str("1g") | str("10g") | str("20g") | str("30g") | str("40g") | str("50g") | str("60g") | str("70g") | str("80g") | str("90g") | str("100g") | str("200g") | str("300g") | str("400g") | str("480g") | arg)
                                    )
                                )
                            )
                        )
                    ),
                    a(str("port"), arg)
                )
            ),
            b(str("interface-type"),
              (str("ge") | str("xe") | str("et"))
            ),
            b(str("inline-services"),
                c(
                    b(str("bandwidth"),
                      (str("1g") | str("10g") | str("20g") | str("30g") | str("40g") | str("50g") | str("60g") | str("70g") | str("80g") | str("90g") | str("100g") | str("200g") | str("300g") | str("400g") | str("480g") | arg)
                    ),
                    a(str("fragmentation-mtu"), arg),
                    a(str("reassembly-context-age"), arg),
                    b(str("service-plane-recovery"),
                        c(
                            str("disable"),
                            a(str("downtime-gap-seconds"), arg),
                            a(str("downtime-events"), arg)
                        )
                    )
                )
            ),
            c(
              b(str("adaptive-services"),
                  c(
                      b(str("service-package"),
                          c(
                              c(
                                str("layer-3"),
                                str("layer-2"),
                                str("layer-2-3"),
                                b(str("extension-provider"),
                                    c(
                                        a(str("data-pollers"), arg),
                                        b(str("data-flow-affinity"),
                                            c(
                                                b(str("hash-key"),
                                                  (str("layer-3") | str("layer-4"))
                                                )
                                            )
                                        ),
                                        str("session-offload"),
                                        str("no-default-packages"),
                                        a(str("package"), arg),
                                        a(str("syslog"), enum(str("external") | str("pfe") | str("daemon") | str("kernel")),
                                            c(
                                                c(
                                                  str("any"),
                                                  str("emergency"),
                                                  str("alert"),
                                                  str("critical"),
                                                  str("error"),
                                                  str("warning"),
                                                  str("notice"),
                                                  str("info"),
                                                  str("none")
                                                ),
                                                b(str("destination"),
                                                  (str("routing-engine") | str("pic-console"))
                                                )
                                            )
                                        )
                                    )
                                )
                              )
                          )
                      )
                  )
              ),
              b(str("monitoring-services"),
                  c(
                      b(str("application"),
                        (str("dynamic-flow-capture") | str("flow-collector") | str("monitor"))
                      )
                  )
              )
            ),
            str("no-mcast-replication"),
            b(str("ggsn-services"),
                c(
                    b(str("application"),
                      (str("ggsn-data") | str("ggsn-inspection") | str("ggsn-tunnel"))
                    )
                )
            ),
            b(str("framing"),
              (str("sonet") | str("sdh") | str("t3") | str("e3") | str("t1") | str("e1") | str("lan"))
            ),
            b(str("synchronization"),
                c(
                    c(
                      a(str("port"), arg)
                    )
                )
            ),
            b(str("recovered-clock"),
                c(
                    a(str("port"), arg),
                    a(str("channel"), arg)
                )
            ),
            b(str("vtmapping"),
              (str("klm") | str("itu-t"))
            ),
            str("no-concatenate"),
            str("no-multi-rate"),
            str("channelization"),
            str("linerate-mode"),
            b(str("speed"),
              (str("1G"))
            ),
            str("mixed-rate-mode"),
            str("no-pre-classifier"),
            str("aggregate-ports"),
            a(str("number-of-ports"), arg),
            b(str("power"),
              (str("off"))
            ),
            a(str("pic-type"), arg),
            b(str("aggregated-devices"),
                c(
                    b(str("ima"),
                        c(
                            a(str("device-count"), arg)
                        )
                    )
                )
            ),
            str("sparse-dlcis"),
            str("multi-link-layer-2-inline"),
            b(str("q-pic-large-buffer"),
                c(
                    c(
                      str("small-scale"),
                      str("large-scale")
                    )
                )
            ),
            b(str("red-buffer-occupancy"),
                c(
                    b(str("weighted-averaged"),
                        c(
                            a(str("instant-usage-weight-exponent"), arg)
                        )
                    )
                )
            ),
            b(str("traffic-manager"),
                c(
                    a(str("ingress-shaping-overhead"), arg),
                    a(str("egress-shaping-overhead"), arg),
                    b(str("queue-buffer-size"),
                      (str("small"))
                    ),
                    b(str("mode"),
                      (str("egress-only") | str("session-shaping") | str("ingress-and-egress"))
                    )
                )
            ),
            b(str("idle-cell-format"),
                c(
                    str("itu-t"),
                    a(str("payload-pattern"), arg)
                )
            ),
            b(str("atm-l2circuit-mode"),
                c(
                    c(
                      str("aal5"),
                      str("cell"),
                      b(str("trunk"),
                          c(
                              c(
                                str("uni"),
                                str("nni")
                              )
                          )
                      )
                    )
                )
            ),
            str("atm-cell-relay-accumulation"),
            b(str("services-offload"),
                c(
                    str("per-session-statistics"),
                    str("low-latency")
                )
            ),
            a(str("mlfr-uni-nni-bundles"), arg),
            a(str("mlfr-uni-nni-bundles-inline"), arg),
            b(str("ct3"),
                c(
                    b(str("port"),
                      ct3_port_type
                    )
                )
            ),
            b(str("ce1"),
                c(
                    b(str("e1"),
                      ce1_channel_type
                    )
                )
            ),
            b(str("max-queues-per-interface"),
              (str("4") | str("8"))
            ),
            b(str("shdsl"),
                c(
                    b(str("pic-mode"),
                      (str("1-port-atm") | str("2-port-atm") | str("4-port-atm") | str("efm"))
                    )
                )
            ),
            b(str("ethernet"),
                c(
                    b(str("pic-mode"),
                      (str("switching") | str("routing") | str("enhanced-switching"))
                    )
                )
            ),
            str("tunnel-queuing"),
            a(str("port-mirror-instance"), arg),
            b(str("port"),
              chassis_pic_port_framing
            ),
            b(str("port-range"),
                s(
                        arg,
                        arg,
                  c(
                    b(str("short-reach-mode"),
                      (str("disable") | str("enable"))
                    ),
                    b(str("channel-speed"),
                      (str("10g") | str("25g") | str("50g") | str("disable-auto-speed-detection"))
                    )
                  )
                )
            ),
            b(str("fibre-channel"),
              chassis_fibre_channel_type
            ),
            b(str("xe"),
                c(
                    b(str("port"),
                        s(
                                arg
                        )
                    ),
                    b(str("port-range"),
                        s(
                                arg,
                                arg
                        )
                    )
                )
            ),
            b(str("xle"),
                c(
                    b(str("port"),
                        s(
                                arg
                        )
                    ),
                    b(str("port-range"),
                        s(
                                arg,
                                arg
                        )
                    )
                )
            ),
            b(str("fte"),
                c(
                    b(str("port"),
                        s(
                                arg
                        )
                    ),
                    b(str("port-range"),
                        s(
                                arg,
                                arg
                        )
                    )
                )
            ),
            b(a(str("qsfp-port"), arg),
                c(
                    b(str("port-mode"),
                      (str("40g") | str("10g"))
                    )
                )
            ),
            b(str("sfpplus"),
                c(
                    b(str("pic-mode"),
                      (str("1g") | str("10g"))
                    )
                )
            ),
            b(str("hash-key"),
                c(
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("layer-3"),
                                        c(
                                            str("destination-address")
                                        )
                                    ),
                                    str("layer-4"),
                                    b(str("symmetric-hash"),
                                        c(
                                            str("complement")
                                        )
                                    )
                                )
                            ),
                            b(str("multiservice"),
                                c(
                                    str("source-mac"),
                                    str("destination-mac"),
                                    b(str("payload"),
                                        c(
                                            b(str("ip"),
                                                c(
                                                    b(str("layer-3"),
                                                        c(
                                                            c(
                                                              str("source-ip-only"),
                                                              str("destination-ip-only")
                                                            )
                                                        )
                                                    ),
                                                    str("layer-4")
                                                )
                                            )
                                        )
                                    ),
                                    b(str("symmetric-hash"),
                                        c(
                                            str("complement")
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            a(str("ingress-policer-overhead"), arg),
            a(str("egress-policer-overhead"), arg),
            str("account-layer2-overhead"),
            b(str("forwarding-mode"),
                c(
                    c(
                      str("sa-multicast"),
                      b(str("vlan-steering"),
                          c(
                              b(str("vlan-rule"),
                                (str("odd-even") | str("high-low"))
                              )
                          )
                      )
                    )
                )
            ),
            str("subscriber-aware-services"),
            str("ptp-mode")
        )
      )
    end

    rule(:ce1_channel_type) do
      b(arg.as(:arg),
        c(
            b(a(str("channel-group"), arg),
                sc(
                    a(str("timeslots"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:chassis_fibre_channel_type) do
        c(
            a(str("port"), arg),
            b(str("port-range"),
                s(
                        arg,
                        arg
                )
            )
        )
    end

    rule(:chassis_pic_port_framing) do
      b(arg.as(:arg),
        c(
            b(str("short-reach-mode"),
              (str("disable") | str("enable"))
            ),
            b(str("framing"),
              (str("sonet") | str("sdh") | str("t3") | str("e3") | str("t1") | str("e1"))
            ),
            a(str("number-of-sub-ports"), arg),
            str("unused"),
            b(str("speed"),
              (str("oc3-stm1") | str("oc12-stm4") | str("oc48-stm16") | str("1G") | str("10g") | str("25g") | str("40g") | str("100g") | str("50g") | str("200g") | str("400g"))
            ),
            b(str("channel-speed"),
              (str("10g") | str("25g") | str("50g") | str("disable-auto-speed-detection"))
            ),
            b(str("forwarding-mode"),
                c(
                    str("sa-multicast")
                )
            ),
            str("no-mcast-replication"),
            b(str("traffic-manager"),
                c(
                    b(str("mode"),
                      (str("ingress-and-egress"))
                    )
                )
            )
        )
      )
    end

    rule(:chassis_port_type) do
      b(arg.as(:arg),
        c(
            str("tunnel-services")
        )
      )
    end

    rule(:chassis_redundancy_type) do
        c(
            b(str("routing-engine"),
              chassis_rdd_re_type
            ),
            b(str("ssb"),
              chassis_rdd_id_type
            ),
            b(str("cfeb"),
              chassis_rdd_cfeb_id_type
            ),
            b(str("sfm"),
              chassis_rdd_sfm_id_type
            ),
            b(str("failover"),
              chassis_rdd_failover_type
            ),
            a(str("keepalive-time"), arg),
            a(str("mastership-refresh-timeout"), arg),
            b(str("graceful-switchover"),
              chassis_non_stop_forwarding_type
            ),
            b(str("feb"),
                c(
                    b(a(str("redundancy-group"), arg),
                        c(
                            a(str("description"), quote | arg),
                            b(a(str("feb"), arg),
                                c(
                                    c(
                                      str("primary"),
                                      str("backup")
                                    )
                                )
                            ),
                            str("no-auto-failover")
                        )
                    )
                )
            )
        )
    end

    rule(:chassis_non_stop_forwarding_type) do
        c(
            b(str("traceoptions"),
                c(
                    a(str("flag"), enum(str("update") | str("all"))).as(:oneline)
                )
            )
        )
    end

    rule(:chassis_rdd_cfeb_id_type) do
      b(arg.as(:arg),
        c(
            c(
              str("always"),
              str("preferred")
            )
        )
      ).as(:oneline)
    end

    rule(:chassis_rdd_failover_type) do
        c(
            str("on-loss-of-keepalives"),
            str("on-re-to-fpc-stale"),
            str("on-disk-failure"),
            str("not-on-disk-underperform"),
            a(str("disk-read-threshold"), arg),
            a(str("disk-write-threshold"), arg),
            str("on-loss-of-vm-host-connection")
        )
    end

    rule(:chassis_rdd_id_type) do
      b(arg.as(:arg),
        c(
            c(
              str("always"),
              str("preferred")
            )
        )
      ).as(:oneline)
    end

    rule(:chassis_rdd_re_type) do
      b(arg.as(:arg),
        c(
            c(
              str("master"),
              str("backup"),
              str("disabled")
            )
        )
      ).as(:oneline)
    end

    rule(:chassis_rdd_sfm_id_type) do
      b(arg.as(:arg),
        c(
            c(
              str("always"),
              str("preferred")
            )
        )
      ).as(:oneline)
    end

    rule(:chassis_routing_engine_type) do
        c(
            b(str("on-disk-failure"),
              chassis_re_on_disk_failure
            ),
            b(str("control-interface"),
                c(
                    b(str("recovery-method"),
                      (str("disable-recovery") | str("socket") | str("counter"))
                    ),
                    str("pause-frame")
                )
            ),
            b(str("bios"),
                c(
                    str("no-auto-upgrade"),
                    str("uninterrupt")
                )
            ),
            b(str("disk"),
                c(
                    str("smart-check"),
                    b(a(str("ssd-series"), arg),
                        c(
                            b(a(str("id"), arg),
                                c(
                                    a(str("id-threshold"), arg),
                                    b(str("id-value"),
                                      (str("raw") | str("norm"))
                                    ),
                                    b(str("id-flag"),
                                      (str("low") | str("high"))
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("usb-wwan"),
                c(
                    b(str("port"),
                      (str("0") | str("1"))
                    )
                )
            )
        )
    end

    rule(:chassis_re_on_disk_failure) do
        c(
            c(
              str("reboot"),
              b(str("disk-failure-action"),
                (str("reboot") | str("halt"))
              )
            ),
            str("failover")
        ).as(:oneline)
    end

    rule(:chassis_sfm_type) do
      b(arg.as(:arg),
        c(
            b(str("power"),
              (str("off") | str("on"))
            ),
            c(
              str("disable-power")
            )
        )
      )
    end

    rule(:chassis_sib_type) do
        c(
            b(a(str("slot"), arg),
                c(
                    b(str("error"),
                      chassis_sib_error_type
                    )
                )
            ),
            a(str("minimum"), arg),
            b(str("power-off"),
                c(
                    a(str("slot"), arg)
                )
            )
        )
    end

    rule(:chassis_sib_error_type) do
        c(
            b(str("fatal"),
              chassis_sib_error_level_major_fatal
            ),
            b(str("major"),
              chassis_sib_error_level_major_fatal
            ),
            b(str("minor"),
              chassis_sib_error_level_minor
            ),
            b(str("scope"),
              chassis_sib_scope_type
            )
        )
    end

    rule(:chassis_sib_error_level_major_fatal) do
        c(
            a(str("threshold"), arg),
            a(str("action"), enum(str("reset") | str("offline") | str("alarm") | str("get-state") | str("log")))
        )
    end

    rule(:chassis_sib_error_level_minor) do
        c(
            a(str("threshold"), arg),
            a(str("action"), enum(str("reset") | str("offline") | str("alarm") | str("get-state") | str("log")))
        )
    end

    rule(:chassis_sib_scope_type) do
        c(
            b(str("board"),
              chassis_sib_scope_category
            ),
            b(str("switch"),
              chassis_sib_scope_category
            )
        )
    end

    rule(:chassis_sib_scope_category) do
        c(
            b(str("category"),
              chassis_sib_scope_category_type
            )
        )
    end

    rule(:chassis_sib_scope_category_type) do
        c(
            b(str("functional"),
              chassis_sib_scope_category_error_type
            ),
            b(str("memory"),
              chassis_sib_scope_category_error_type
            ),
            b(str("io"),
              chassis_sib_scope_category_error_type
            ),
            b(str("storage"),
              chassis_sib_scope_category_error_type
            ),
            b(str("switch"),
              chassis_sib_scope_category_error_type
            ),
            b(str("processing"),
              chassis_sib_scope_category_error_type
            )
        )
    end

    rule(:chassis_sib_scope_category_error_type) do
        c(
            b(str("fatal"),
              chassis_sib_error_level_type
            ),
            b(str("major"),
              chassis_sib_error_level_type
            ),
            b(str("minor"),
              chassis_sib_error_level_type
            )
        )
    end

    rule(:chassis_sib_error_level_type) do
        c(
            a(str("threshold"), arg),
            a(str("action"), enum(str("reset") | str("offline") | str("alarm") | str("get-state") | str("log")))
        )
    end

    rule(:chassisd_redundancy_group_type) do
        c(
            b(str("interface-type"),
                c(
                    b(str("redundant-logical-tunnel"),
                        c(
                            a(str("device-count"), arg)
                        )
                    ),
                    b(str("redundant-virtual-tunnel"),
                        c(
                            a(str("device-count"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:chassisd_agg_container_type) do
        c(
            a(str("device-count"), arg)
        )
    end

    rule(:chassisd_agg_enet_type) do
        c(
            a(str("device-count"), arg),
            b(str("lacp"),
                c(
                    a(str("system-priority"), arg),
                    b(str("link-protection"),
                        c(
                            str("non-revertive")
                        )
                    )
                )
            )
        )
    end

    rule(:chassisd_agg_pos_type) do
        c(
            a(str("device-count"), arg)
        )
    end

    rule(:chassisd_provider_instance_type) do
        c(
            a(str("device-count"), arg)
        )
    end

    rule(:client_address_object) do
      b(arg.as(:arg),
        c(
            str("restrict")
        )
      )
    end

    rule(:collector_destinations_type) do
      b(arg.as(:arg),
        c(
            b(str("password"),
              unreadable
            )
        )
      )
    end

    rule(:collector_transfer_log_archive_type) do
        c(
            a(str("filename-prefix"), arg),
            a(str("maximum-age"), arg),
            b(a(str("archive-sites"), arg),
                sc(
                    b(str("password"),
                      unreadable
                    )
                )
            ).as(:oneline)
        )
    end

    rule(:comm_object) do
        c(
            a(str("snmp-community"), arg),
            str("no-default-comm-to-v3-config")
        )
    end

    rule(:cos_object) do
        c(
            b(str("application-profile"),
              cos_application_profile_object
            ),
            b(str("rule"),
              cos_rule_object
            ),
            b(a(str("rule-set"), arg),
                c(
                    a(str("rule"), arg)
                )
            )
        )
    end

    rule(:cos_application_profile_object) do
      b(arg.as(:arg),
        c(
            b(str("sip"),
                c(
                    b(str("voice"),
                        c(
                            a(str("dscp"), arg),
                            a(str("forwarding-class"), arg)
                        )
                    ),
                    b(str("video"),
                        c(
                            a(str("dscp"), arg),
                            a(str("forwarding-class"), arg)
                        )
                    )
                )
            ),
            b(str("ftp"),
                c(
                    b(str("data"),
                        c(
                            a(str("dscp"), arg),
                            a(str("forwarding-class"), arg)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:cos_policer) do
      b(arg.as(:arg),
        c(
            b(str("premium"),
              ethernet_policer
            ),
            b(str("aggregate"),
              ethernet_policer
            )
        )
      )
    end

    rule(:cos_policer_input_priority_map) do
        c(
            b(str("ieee-802.1p"),
                c(
                    a(str("premium"), arg)
                )
            )
        )
    end

    rule(:cos_policer_output_priority_map) do
        c(
            b(str("classifier"),
                c(
                    b(str("premium"),
                        c(
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), enum(str("low") | str("high"))).as(:oneline)
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:cos_rule_object) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("input") | str("output") | str("input-output"))
            ),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      sfw_match_object
                    ),
                    b(str("then"),
                        c(
                            a(str("dscp"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("application-profile"), arg),
                            str("syslog"),
                            c(
                              str("reflexive"),
                              str("revert"),
                              b(str("reverse"),
                                  c(
                                      a(str("dscp"), arg),
                                      a(str("forwarding-class"), arg),
                                      a(str("application-profile"), arg),
                                      str("syslog")
                                  )
                              )
                            )
                        )
                    )
                )
            ),
            b(a(str("policy"), arg),
                c(
                    b(str("match"),
                      sfw_match_object
                    ),
                    b(str("then"),
                        c(
                            a(str("dscp"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("application-profile"), arg),
                            c(
                              str("reflexive"),
                              str("revert"),
                              b(str("reverse"),
                                  c(
                                      a(str("dscp"), arg),
                                      a(str("forwarding-class"), arg),
                                      a(str("application-profile"), arg)
                                  )
                              )
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:cpcd_rule_object_type) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("input") | str("output") | str("input-output"))
            ),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      cpcd_match_object_type
                    ),
                    b(str("then"),
                      cpcd_action_object_type
                    )
                )
            )
        )
      )
    end

    rule(:cpcd_action_object_type) do
        c(
            c(
              str("accept"),
              b(str("rewrite"),
                  c(
                      b(str("destination-address"),
                        ipaddr
                      ),
                      a(str("destination-port"), arg)
                  )
              ),
              b(str("redirect"),
                  sc(
                      arg
                  )
              ).as(:oneline),
              b(str("insert"),
                  c(
                      b(a(str("tag"), arg),
                          c(
                              b(str("tag-value"),
                                (str("subscriber-mac-addr") | str("subscriber-ip") | str("subscriber-ipv6") | str("hostname") | arg)
                              )
                          )
                      )
                  )
              )
            ),
            str("syslog")
        )
    end

    rule(:cpcd_match_object_type) do
        c(
            a(str("destination-address"), str("any-unicast") | arg,
                sc(
                    str("except")
                )
            ).as(:oneline),
            b(str("destination-address-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg),
                  c(
                    str("except")
                  )
                )
            ).as(:oneline),
            b(a(str("destination-prefix-list"), arg),
                sc(
                    str("except")
                )
            ).as(:oneline),
            b(a(str("applications"), arg),
                c(
                    b(str("application-protocol"),
                      (str("bootp") | str("dce-rpc") | str("dce-rpc-portmap") | str("dns") | str("exec") | str("ftp") | str("ftp-data") | str("gprs-gtp-c") | str("gprs-gtp-u") | str("gprs-gtp-v0") | str("gprs-sctp") | str("h323") | str("icmpv6") | str("icmp") | str("ignore") | str("iiop") | str("ike-esp-nat") | str("ip") | str("login") | str("mgcp-ca") | str("mgcp-ua") | str("ms-rpc") | str("netbios") | str("netshow") | str("none") | str("pptp") | str("q931") | str("ras") | str("realaudio") | str("rpc") | str("rpc-portmap") | str("rsh") | str("rtsp") | str("sccp") | str("sip") | str("shell") | str("snmp") | str("sqlnet") | str("sqlnet-v2") | str("sun-rpc") | str("talk") | str("tftp") | str("traceroute") | str("https") | str("winframe") | str("http") | str("imap") | str("smtp") | str("ssh") | str("telnet") | str("twamp"))
                    ),
                    b(str("protocol"),
                      (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
                    ),
                    b(str("source-port"),
                      (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                    ),
                    b(str("destination-port"),
                      (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                    )
                )
            )
        )
    end

    rule(:cpcd_trace_options_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("configuration") | str("clicommand") | str("general") | str("rtsock") | str("statistics") | str("rules") | str("ssets") | str("ipc") | str("gres") | str("re-services") | str("re-svc-debug-stat") | str("all"))).as(:oneline)
        )
    end

    rule(:ct3_port_type) do
      b(arg.as(:arg),
        c(
            b(str("t1"),
              ct3_channel_type
            )
        )
      )
    end

    rule(:ct3_channel_type) do
      b(arg.as(:arg),
        c(
            b(a(str("channel-group"), arg),
                sc(
                    a(str("timeslots"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:custom_attack_group_type) do
      b(arg.as(:arg),
        c(
            a(str("attack-group-description"), arg),
            a(str("group-members"), arg)
        )
      )
    end

    rule(:custom_attack_type) do
      b(arg.as(:arg),
        c(
            a(str("attack-description"), arg),
            b(str("recommended-action"),
              (str("none") | str("ignore") | str("drop-packet") | str("drop") | str("close-client") | str("close-server") | str("close"))
            ),
            b(str("severity"),
              (str("info") | str("warning") | str("minor") | str("major") | str("critical"))
            ),
            b(str("time-binding"),
                c(
                    a(str("count"), arg),
                    b(str("scope"),
                      (str("peer") | str("source") | str("destination"))
                    ),
                    a(str("interval"), arg)
                )
            ),
            b(str("attack-type"),
                c(
                    b(str("signature"),
                        c(
                            b(str("protocol-binding"),
                                c(
                                    c(
                                      b(str("tcp"),
                                          c(
                                              b(str("minimum-port"),
                                                port_range
                                              )
                                          )
                                      ),
                                      b(str("udp"),
                                          c(
                                              b(str("minimum-port"),
                                                port_range
                                              )
                                          )
                                      ),
                                      b(str("rpc"),
                                          c(
                                              a(str("program-number"), arg)
                                          )
                                      ),
                                      str("icmpv6"),
                                      str("icmp"),
                                      b(str("ip"),
                                          c(
                                              a(str("protocol-number"), arg)
                                          )
                                      ),
                                      b(str("ipv6"),
                                          c(
                                              a(str("protocol-number"), arg)
                                          )
                                      ),
                                      a(str("application"), arg),
                                      a(str("nested-application"), arg)
                                    )
                                )
                            ),
                            a(str("context"), arg),
                            a(str("pattern"), arg),
                            a(str("pattern-pcre"), arg),
                            b(str("optional-parameters"),
                                c(
                                    a(str("min-offset"), arg),
                                    a(str("max-offset"), arg),
                                    a(str("min-length"), arg),
                                    a(str("edit-distance"), arg),
                                    a(str("hamming-distance"), arg)
                                )
                            ),
                            a(str("regexp"), arg),
                            str("negate"),
                            b(str("direction"),
                              (str("client-to-server") | str("server-to-client") | str("any"))
                            ),
                            b(str("shellcode"),
                              (str("intel") | str("sparc") | str("all") | str("no-shellcode"))
                            ),
                            b(str("protocol"),
                                c(
                                    b(str("ipv4"),
                                        c(
                                            b(str("tos"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ihl"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("total-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ip-flags"),
                                                sc(
                                                    str("rb"),
                                                    str("no-rb"),
                                                    str("mf"),
                                                    str("no-mf"),
                                                    str("df"),
                                                    str("no-df")
                                                )
                                            ).as(:oneline),
                                            b(str("ttl"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("protocol"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("source"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    b(str("value"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    b(str("value"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("ipv6"),
                                        c(
                                            b(str("traffic-class"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("payload-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("flow-label"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("hop-limit"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("next-header"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("source"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    b(str("value"),
                                                      ipv6addr
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    b(str("value"),
                                                      ipv6addr
                                                    )
                                                )
                                            ),
                                            b(str("extension-header"),
                                                c(
                                                    b(str("routing-header"),
                                                        c(
                                                            b(str("header-type"),
                                                                c(
                                                                    b(str("match"),
                                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                                    ),
                                                                    a(str("value"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("destination-option"),
                                                        c(
                                                            b(str("option-type"),
                                                                c(
                                                                    b(str("match"),
                                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                                    ),
                                                                    a(str("value"), arg)
                                                                )
                                                            ),
                                                            b(str("home-address"),
                                                                c(
                                                                    b(str("match"),
                                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                                    ),
                                                                    b(str("value"),
                                                                      ipv6addr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("tcp"),
                                        c(
                                            b(str("source-port"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("destination-port"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ack-number"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("header-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("reserved"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("window-size"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("urgent-pointer"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("tcp-flags"),
                                                sc(
                                                    str("r1"),
                                                    str("no-r1"),
                                                    str("r2"),
                                                    str("no-r2"),
                                                    str("urg"),
                                                    str("no-urg"),
                                                    str("ack"),
                                                    str("no-ack"),
                                                    str("psh"),
                                                    str("no-psh"),
                                                    str("rst"),
                                                    str("no-rst"),
                                                    str("syn"),
                                                    str("no-syn"),
                                                    str("fin"),
                                                    str("no-fin")
                                                )
                                            ).as(:oneline),
                                            b(str("option"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("window-scale"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("mss"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("udp"),
                                        c(
                                            b(str("source-port"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("destination-port"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("icmp"),
                                        c(
                                            b(str("type"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("code"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("icmpv6"),
                                        c(
                                            b(str("type"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("code"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("anomaly"),
                        c(
                            a(str("service"), arg),
                            a(str("test"), arg),
                            b(str("direction"),
                              (str("client-to-server") | str("server-to-client") | str("any"))
                            ),
                            b(str("shellcode"),
                              (str("intel") | str("sparc") | str("all") | str("no-shellcode"))
                            )
                        )
                    ),
                    b(str("chain"),
                        c(
                            b(str("protocol-binding"),
                                c(
                                    c(
                                      b(str("tcp"),
                                          c(
                                              b(str("minimum-port"),
                                                port_range
                                              )
                                          )
                                      ),
                                      b(str("udp"),
                                          c(
                                              b(str("minimum-port"),
                                                port_range
                                              )
                                          )
                                      ),
                                      b(str("rpc"),
                                          c(
                                              a(str("program-number"), arg)
                                          )
                                      ),
                                      str("icmpv6"),
                                      str("icmp"),
                                      b(str("ip"),
                                          c(
                                              a(str("protocol-number"), arg)
                                          )
                                      ),
                                      b(str("ipv6"),
                                          c(
                                              a(str("protocol-number"), arg)
                                          )
                                      ),
                                      a(str("application"), arg),
                                      a(str("nested-application"), arg)
                                    )
                                )
                            ),
                            b(str("scope"),
                              (str("session") | str("transaction"))
                            ),
                            str("order"),
                            str("reset"),
                            a(str("expression"), arg),
                            b(str("member"),
                              chain_member_type
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:chain_member_type) do
      b(arg.as(:arg),
        c(
            b(str("attack-type"),
                c(
                    b(str("signature"),
                        c(
                            a(str("context"), arg),
                            a(str("pattern"), arg),
                            a(str("pattern-pcre"), arg),
                            b(str("optional-parameters"),
                                c(
                                    a(str("min-offset"), arg),
                                    a(str("max-offset"), arg),
                                    a(str("min-length"), arg),
                                    a(str("edit-distance"), arg),
                                    a(str("hamming-distance"), arg)
                                )
                            ),
                            a(str("regexp"), arg),
                            str("negate"),
                            b(str("direction"),
                              (str("client-to-server") | str("server-to-client") | str("any"))
                            ),
                            b(str("shellcode"),
                              (str("intel") | str("sparc") | str("all") | str("no-shellcode"))
                            ),
                            b(str("protocol"),
                                c(
                                    b(str("ipv4"),
                                        c(
                                            b(str("tos"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ihl"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("total-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ip-flags"),
                                                sc(
                                                    str("rb"),
                                                    str("no-rb"),
                                                    str("mf"),
                                                    str("no-mf"),
                                                    str("df"),
                                                    str("no-df")
                                                )
                                            ).as(:oneline),
                                            b(str("ttl"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("protocol"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("source"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    b(str("value"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    b(str("value"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("ipv6"),
                                        c(
                                            b(str("traffic-class"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("payload-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("flow-label"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("hop-limit"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("next-header"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("source"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    b(str("value"),
                                                      ipv6addr
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    b(str("value"),
                                                      ipv6addr
                                                    )
                                                )
                                            ),
                                            b(str("extension-header"),
                                                c(
                                                    b(str("routing-header"),
                                                        c(
                                                            b(str("header-type"),
                                                                c(
                                                                    b(str("match"),
                                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                                    ),
                                                                    a(str("value"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("destination-option"),
                                                        c(
                                                            b(str("option-type"),
                                                                c(
                                                                    b(str("match"),
                                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                                    ),
                                                                    a(str("value"), arg)
                                                                )
                                                            ),
                                                            b(str("home-address"),
                                                                c(
                                                                    b(str("match"),
                                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                                    ),
                                                                    b(str("value"),
                                                                      ipv6addr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("tcp"),
                                        c(
                                            b(str("source-port"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("destination-port"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ack-number"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("header-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("reserved"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("window-size"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("urgent-pointer"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("tcp-flags"),
                                                sc(
                                                    str("r1"),
                                                    str("no-r1"),
                                                    str("r2"),
                                                    str("no-r2"),
                                                    str("urg"),
                                                    str("no-urg"),
                                                    str("ack"),
                                                    str("no-ack"),
                                                    str("psh"),
                                                    str("no-psh"),
                                                    str("rst"),
                                                    str("no-rst"),
                                                    str("syn"),
                                                    str("no-syn"),
                                                    str("fin"),
                                                    str("no-fin")
                                                )
                                            ).as(:oneline),
                                            b(str("option"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("window-scale"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("mss"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("udp"),
                                        c(
                                            b(str("source-port"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("destination-port"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("icmp"),
                                        c(
                                            b(str("type"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("code"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("icmpv6"),
                                        c(
                                            b(str("type"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("code"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("checksum-validate"),
                                                c(
                                                    b(str("match"),
                                                      (str("equal") | str("greater-than") | str("less-than") | str("not-equal"))
                                                    ),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("anomaly"),
                        c(
                            a(str("test"), arg),
                            b(str("direction"),
                              (str("client-to-server") | str("server-to-client") | str("any"))
                            ),
                            b(str("shellcode"),
                              (str("intel") | str("sparc") | str("all") | str("no-shellcode"))
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:dcd_rx_bucket_config) do
        c(
            b(str("overflow"),
              (str("tag") | str("discard"))
            ),
            a(str("rate"), arg),
            a(str("threshold"), arg)
        )
    end

    rule(:dcd_shaping_config) do
        c(
            c(
              b(str("cbr"),
                  sc(
                      arg,
                      a(str("cdvt"), arg)
                  )
              ).as(:oneline),
              b(str("vbr"),
                  sc(
                      a(str("peak"), arg),
                      a(str("sustained"), arg),
                      a(str("burst"), arg),
                      a(str("cdvt"), arg)
                  )
              ).as(:oneline),
              b(str("rtvbr"),
                  sc(
                      a(str("peak"), arg),
                      a(str("sustained"), arg),
                      a(str("burst"), arg),
                      a(str("cdvt"), arg)
                  )
              ).as(:oneline)
            ),
            a(str("queue-length"), arg)
        )
    end

    rule(:dcd_tx_bucket_config) do
        c(
            b(str("overflow"),
              (str("discard"))
            ),
            a(str("rate"), arg),
            a(str("threshold"), arg)
        )
    end

    rule(:demux_options_type) do
        c(
            b(str("underlying-interface"),
              (arg | arg | arg)
            )
        )
    end

    rule(:dfc_group_type) do
      b(arg.as(:arg),
        c(
            b(str("interfaces"),
              interface_device
            ),
            a(str("input-packet-rate-threshold"), arg),
            a(str("max-duplicates"), arg),
            a(str("duplicates-dropped-periodicity"), arg),
            b(str("pic-memory-threshold"),
                sc(
                    a(str("percentage"), arg)
                )
            ).as(:oneline),
            b(str("control-source"),
              dfc_control_source_type
            ),
            b(str("content-destination"),
              content_destination_type
            )
        )
      )
    end

    rule(:content_destination_type) do
      b(arg.as(:arg),
        c(
            b(str("address"),
              ipv4addr
            ),
            a(str("ttl"), arg),
            a(str("soft-limit-clear"), arg),
            a(str("soft-limit"), arg),
            a(str("hard-limit-target"), arg),
            a(str("hard-limit"), arg)
        )
      )
    end

    rule(:dfc_control_source_type) do
      b(arg.as(:arg),
        c(
            b(str("source-addresses"),
              ipv4addr
            ),
            a(str("service-port"), arg),
            b(str("notification-targets"),
              dfc_notification_target_type
            ).as(:oneline),
            str("no-syslog"),
            a(str("shared-key"), arg),
            a(str("allowed-destinations"), arg),
            a(str("minimum-priority"), arg)
        )
      )
    end

    rule(:dfc_notification_target_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg)
        )
      ).as(:oneline)
    end

    rule(:dhcp_client_type) do
        c(
            b(str("client-identifier"),
                c(
                    c(
                      a(str("ascii"), arg),
                      a(str("hexadecimal"), arg)
                    ),
                    b(str("user-id"),
                        sc(
                            c(
                              a(str("ascii"), arg),
                              a(str("hexadecimal"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("prefix"),
                        c(
                            str("host-name"),
                            str("logical-system-name"),
                            str("routing-instance-name")
                        )
                    ),
                    b(str("use-interface-description"),
                      (str("logical") | str("device"))
                    ),
                    a(str("hardware-type"), arg)
                )
            ),
            str("no-dns-install"),
            b(str("lease-time"),
              (str("infinite") | arg)
            ),
            a(str("retransmission-attempt"), arg),
            a(str("retransmission-interval"), arg),
            a(str("metric"), arg),
            b(str("server-address"),
              ipv4addr
            ),
            str("update-server"),
            a(str("vendor-id"), arg),
            str("force-discover"),
            b(str("options"),
                c(
                    b(a(str("number"), arg),
                        sc(
                            c(
                              a(str("hex-string"), arg)
                            )
                        )
                    ).as(:oneline),
                    str("no-hostname")
                )
            ),
            a(str("requested-options"), arg).as(:oneline)
        )
    end

    rule(:drop_policy_term) do
      b(arg.as(:arg),
        c(
            b(str("from"),
                c(
                    b(str("source-address"),
                      li_policy_addr_simple_object
                    ),
                    b(str("destination-address"),
                      li_policy_addr_simple_object
                    ),
                    c(
                      b(str("source-port"),
                        match_li_simple_port_value
                      )
                    ),
                    c(
                      b(str("destination-port"),
                        match_li_simple_port_value
                      )
                    ),
                    c(
                      b(str("protocol"),
                        match_li_simple_protocol_value
                      )
                    ),
                    c(
                      b(str("dscp"),
                        match_li_simple_dscp_value
                      )
                    )
                )
            )
        )
      )
    end

    rule(:drop_policy6_term) do
      b(arg.as(:arg),
        c(
            b(str("from"),
                c(
                    b(str("source-address"),
                      li_policy_addr6_simple_object
                    ),
                    b(str("destination-address"),
                      li_policy_addr6_simple_object
                    ),
                    c(
                      b(str("source-port"),
                        match_li_simple_port_value
                      )
                    ),
                    c(
                      b(str("destination-port"),
                        match_li_simple_port_value
                      )
                    ),
                    c(
                      b(str("protocol"),
                        match_li_simple_protocol_value
                      )
                    ),
                    c(
                      b(str("dscp"),
                        match_li_simple_dscp_value
                      )
                    )
                )
            )
        )
      )
    end

    rule(:dslite_object) do
      b(arg.as(:arg),
        c(
            b(str("softwire-address"),
              ipv6addr
            ),
            a(str("mtu-v6"), arg),
            str("copy-dscp"),
            str("auto-update-mtu"),
            a(str("flow-limit"), arg),
            a(str("session-limit-per-prefix"), arg)
        )
      )
    end

    rule(:dynamic_attack_group_type) do
      b(arg.as(:arg),
        c(
            a(str("attack-group-description"), arg),
            b(str("filters"),
                c(
                    b(str("direction"),
                        c(
                            b(str("expression"),
                              (str("and") | str("or"))
                            ),
                            b(str("values"),
                              (str("client-to-server") | str("server-to-client") | str("any") | str("exclude-client-to-server") | str("exclude-server-to-client") | str("exclude-any"))
                            )
                        )
                    ),
                    b(str("severity"),
                        c(
                            b(str("values"),
                              (str("info") | str("warning") | str("minor") | str("major") | str("critical"))
                            )
                        )
                    ),
                    b(str("type"),
                        c(
                            b(str("values"),
                              (str("signature") | str("anomaly"))
                            )
                        )
                    ),
                    str("recommended"),
                    str("no-recommended"),
                    b(str("performance"),
                        c(
                            b(str("values"),
                              (str("unknown") | str("fast") | str("normal") | str("slow"))
                            )
                        )
                    ),
                    b(str("category"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    b(str("service"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    b(str("false-positives"),
                        c(
                            b(str("values"),
                              (str("unknown") | str("rarely") | str("occasionally") | str("frequently"))
                            )
                        )
                    ),
                    b(str("vendor"),
                      vendor_object
                    ),
                    b(str("file-type"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    b(str("vulnerability-type"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    str("excluded"),
                    str("no-excluded"),
                    a(str("cvss-score"), str("greater-than") | str("less-than"),
                        c(
                            a(str("value"), arg)
                        )
                    ),
                    a(str("age-of-attack"), str("greater-than") | str("less-than"),
                        c(
                            a(str("value"), arg)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:dynamic_ifbw_parms_type) do
        c(
            a(str("capacity"), arg),
            a(str("margin"), arg),
            a(str("delay"), arg),
            a(str("bandwidth"), arg),
            a(str("resource"), arg),
            a(str("latency"), arg),
            a(str("quality"), arg),
            a(str("data-rate"), arg),
            a(str("threshold"), arg),
            b(str("credit"),
                c(
                    a(str("interval"), arg)
                )
            )
        )
    end

    rule(:dynamic_ipv4_type) do
        c(
            b(str("address-ranges"),
                c(
                    b(a(str("dynamic-profile"), arg),
                        c(
                            b(a(str("network"), arg),
                                c(
                                    b(a(str("range"), arg),
                                        c(
                                            b(str("low"),
                                              ipv4prefix
                                            ),
                                            b(str("high"),
                                              ipv4prefix
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("authentication"),
                      dynamic_ip_authentication_type
                    )
                )
            )
        )
    end

    rule(:dynamic_ip_authentication_type) do
        c(
            a(str("password"), arg),
            b(str("username-include"),
                c(
                    a(str("delimiter"), arg),
                    a(str("domain-name"), arg),
                    a(str("user-prefix"), arg),
                    a(str("auth-server-realm"), arg),
                    str("interface-name"),
                    str("source-address")
                )
            )
        )
    end

    rule(:dynamic_ipv6_type) do
        c(
            b(str("prefix-ranges"),
                c(
                    b(a(str("dynamic-profile"), arg),
                        c(
                            b(a(str("prefix"), arg),
                                c(
                                    b(a(str("range"), arg),
                                        c(
                                            b(str("low"),
                                              ipv6prefix
                                            ),
                                            b(str("high"),
                                              ipv6prefix
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("authentication"),
                      dynamic_ip_authentication_type
                    )
                )
            )
        )
    end

    rule(:epd_threshold_config) do
        ca(
            a(str("plp1"), arg)
        ).as(:oneline)
    end

    rule(:es_filter) do
      b(arg.as(:arg),
        c(
            str("interface-specific"),
            str("physical-interface-filter"),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("interface"),
                              match_interface_object
                            ),
                            b(str("source-mac-address"),
                              firewall_mac_addr_object
                            ),
                            b(str("destination-mac-address"),
                              firewall_mac_addr_object
                            ),
                            c(
                              b(str("ether-type"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              ),
                              b(str("ether-type-except"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              )
                            ),
                            c(
                              b(str("l2-encap-type"),
                                    (str("llc-non-snap") | arg)
                              ),
                              b(str("l2-encap-type-except"),
                                    (str("llc-non-snap") | arg)
                              )
                            ),
                            c(
                              a(str("vlan"), arg),
                              a(str("vlan-except"), arg)
                            ),
                            c(
                              a(str("dot1q-tag"), arg),
                              a(str("dot1q-tag-except"), arg)
                            ),
                            c(
                              b(str("dot1q-user-priority"),
                                    (str("best-effort") | str("background") | str("standard") | str("excellent-load") | str("controlled-load") | str("video") | str("voice") | str("network-control") | arg)
                              ),
                              b(str("dot1q-user-priority-except"),
                                    (str("best-effort") | str("background") | str("standard") | str("excellent-load") | str("controlled-load") | str("video") | str("voice") | str("network-control") | arg)
                              )
                            ),
                            b(str("address"),
                              firewall_addr_object
                            ),
                            b(str("source-address"),
                              firewall_addr_object
                            ),
                            b(str("destination-address"),
                              firewall_addr_object
                            ),
                            c(
                              b(str("dscp"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("dscp-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            c(
                              b(str("precedence"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              ),
                              b(str("precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              )
                            ),
                            c(
                              b(str("ip-options"),
                                    (str("any"))
                              ),
                              b(str("ip-options-except"),
                                    (str("any"))
                              )
                            ),
                            a(str("fragment-flags"), arg),
                            str("is-fragment"),
                            c(
                              b(str("protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            a(str("tcp-flags"), arg),
                            str("tcp-initial"),
                            str("tcp-established"),
                            c(
                              b(str("icmp-type"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              ),
                              b(str("icmp-type-except"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-code"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              ),
                              b(str("icmp-code-except"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              )
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ip-source-address"),
                              firewall_addr_object
                            ),
                            b(str("ip-destination-address"),
                              firewall_addr_object
                            ),
                            c(
                              b(str("ip-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ip-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("ip-precedence"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              ),
                              b(str("ip-precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              )
                            ),
                            b(str("ipv6-destination-address"),
                              firewall_addr6_object
                            ),
                            b(str("ipv6-source-address"),
                              firewall_addr6_object
                            ),
                            b(str("ipv6-address"),
                              firewall_addr6_object
                            ),
                            c(
                              b(str("ipv6-next-header"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ipv6-next-header-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("ipv6-payload-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ipv6-payload-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("ipv6-traffic-class"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("ipv6-traffic-class-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            b(str("ipv6-source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ipv6-destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ipv6-prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            c(
                              b(str("vlan-ether-type"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              ),
                              b(str("vlan-ether-type-except"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              )
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            c(
                              a(str("learn-vlan-id"), arg),
                              a(str("learn-vlan-id-except"), arg)
                            ),
                            c(
                              a(str("learn-vlan-1p-priority"), arg),
                              a(str("learn-vlan-1p-priority-except"), arg)
                            ),
                            c(
                              a(str("learn-vlan-dei"), arg),
                              a(str("learn-vlan-dei-except"), arg)
                            ),
                            c(
                              a(str("user-vlan-id"), arg),
                              a(str("user-vlan-id-except"), arg)
                            ),
                            c(
                              a(str("user-vlan-1p-priority"), arg),
                              a(str("user-vlan-1p-priority-except"), arg)
                            ),
                            c(
                              b(str("traffic-type"),
                                    (str("broadcast") | str("multicast") | str("unknown-unicast") | str("known-unicast"))
                              ),
                              b(str("traffic-type-except"),
                                    (str("broadcast") | str("multicast") | str("unknown-unicast") | str("known-unicast"))
                              )
                            ),
                            b(str("ip-address"),
                              firewall_addr_object
                            ),
                            b(str("interface-set"),
                              match_interface_set_object
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              a(str("isid"), arg),
                              a(str("isid-except"), arg)
                            ),
                            c(
                              a(str("isid-priority-code-point"), arg),
                              a(str("isid-priority-code-point-except"), arg)
                            ),
                            c(
                              a(str("isid-dei"), arg),
                              a(str("isid-dei-except"), arg)
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            b(str("to-fabric"),
                              to_fabric_object
                            ),
                            str("from-fabric"),
                            c(
                              b(str("arp-type"),
                                    (str("arp-request") | str("arp-reply") | arg)
                              )
                            ),
                            c(
                              b(str("flexible-match-mask"),
                                match_l2_flexible_mask
                              )
                            ),
                            c(
                              b(str("flexible-match-range"),
                                match_l2_flexible_range
                              )
                            ),
                            b(str("ip-version"),
                                c(
                                    b(str("ipv4"),
                                        c(
                                            b(str("address"),
                                              firewall_addr_object
                                            ),
                                            b(str("source-address"),
                                              firewall_addr_object
                                            ),
                                            b(str("destination-address"),
                                              firewall_addr_object
                                            ),
                                            c(
                                              b(str("dscp"),
                                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                                              ),
                                              b(str("dscp-except"),
                                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("precedence"),
                                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                                              ),
                                              b(str("precedence-except"),
                                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("ip-options"),
                                                    (str("any"))
                                              ),
                                              b(str("ip-options-except"),
                                                    (str("any"))
                                              )
                                            ),
                                            a(str("fragment-flags"), arg),
                                            str("is-fragment"),
                                            c(
                                              b(str("protocol"),
                                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                                              ),
                                              b(str("protocol-except"),
                                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("source-port"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              ),
                                              b(str("source-port-except"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("destination-port"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              ),
                                              b(str("destination-port-except"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("port"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              ),
                                              b(str("port-except"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              )
                                            ),
                                            a(str("tcp-flags"), arg),
                                            str("tcp-initial"),
                                            str("tcp-established"),
                                            c(
                                              b(str("icmp-type"),
                                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                                              ),
                                              b(str("icmp-type-except"),
                                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("icmp-code"),
                                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                                              ),
                                              b(str("icmp-code-except"),
                                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                                              )
                                            ),
                                            b(str("source-prefix-list"),
                                              firewall_prefix_list
                                            ),
                                            b(str("destination-prefix-list"),
                                              firewall_prefix_list
                                            ),
                                            b(str("ip-source-address"),
                                              firewall_addr_object
                                            ),
                                            b(str("ip-destination-address"),
                                              firewall_addr_object
                                            ),
                                            c(
                                              b(str("ip-protocol"),
                                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                                              ),
                                              b(str("ip-protocol-except"),
                                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("ip-precedence"),
                                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                                              ),
                                              b(str("ip-precedence-except"),
                                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                                              )
                                            )
                                        )
                                    ),
                                    b(str("ipv6"),
                                        c(
                                            b(str("source-address"),
                                              firewall_addr6_object
                                            ),
                                            b(str("destination-address"),
                                              firewall_addr6_object
                                            ),
                                            c(
                                              b(str("traffic-class"),
                                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                                              ),
                                              b(str("traffic-class-except"),
                                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("next-header"),
                                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                                              ),
                                              b(str("next-header-except"),
                                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("payload-protocol"),
                                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                                              ),
                                              b(str("payload-protocol-except"),
                                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("source-port"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              ),
                                              b(str("source-port-except"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("destination-port"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              ),
                                              b(str("destination-port-except"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("port"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              ),
                                              b(str("port-except"),
                                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("extension-header"),
                                                    (str("any") | str("hop-by-hop") | str("routing") | str("mobility") | str("esp") | str("fragment") | str("dstopts") | str("ah") | arg)
                                              ),
                                              b(str("extension-header-except"),
                                                    (str("any") | str("hop-by-hop") | str("routing") | str("mobility") | str("esp") | str("fragment") | str("dstopts") | str("ah") | arg)
                                              )
                                            ),
                                            a(str("tcp-flags"), arg),
                                            str("tcp-initial"),
                                            str("tcp-established"),
                                            c(
                                              b(str("icmp-type"),
                                                    (str("destination-unreachable") | str("packet-too-big") | str("time-exceeded") | str("parameter-problem") | str("echo-request") | str("echo-reply") | str("membership-query") | str("membership-report") | str("membership-termination") | str("router-solicit") | str("router-advertisement") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | str("inverse-neighbor-discovery-solicitation") | str("inverse-neighbor-discovery-advertisement") | str("home-agent-address-discovery-request") | str("home-agent-address-discovery-reply") | str("mobile-prefix-solicitation") | str("mobile-prefix-advertisement-reply") | str("certificate-path-solicitation") | str("certificate-path-advertisement") | str("private-experimentation-100") | str("private-experimentation-101") | str("private-experimentation-200") | str("private-experimentation-201") | arg)
                                              ),
                                              b(str("icmp-type-except"),
                                                    (str("destination-unreachable") | str("packet-too-big") | str("time-exceeded") | str("parameter-problem") | str("echo-request") | str("echo-reply") | str("membership-query") | str("membership-report") | str("membership-termination") | str("router-solicit") | str("router-advertisement") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | str("inverse-neighbor-discovery-solicitation") | str("inverse-neighbor-discovery-advertisement") | str("home-agent-address-discovery-request") | str("home-agent-address-discovery-reply") | str("mobile-prefix-solicitation") | str("mobile-prefix-advertisement-reply") | str("certificate-path-solicitation") | str("certificate-path-advertisement") | str("private-experimentation-100") | str("private-experimentation-101") | str("private-experimentation-200") | str("private-experimentation-201") | arg)
                                              )
                                            ),
                                            c(
                                              b(str("icmp-code"),
                                                    (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
                                              ),
                                              b(str("icmp-code-except"),
                                                    (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
                                              )
                                            ),
                                            b(str("source-prefix-list"),
                                              firewall_prefix_list
                                            ),
                                            b(str("destination-prefix-list"),
                                              firewall_prefix_list
                                            ),
                                            b(str("ip6-source-address"),
                                              firewall_addr6_object
                                            ),
                                            b(str("ip6-destination-address"),
                                              firewall_addr6_object
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("vxlan"),
                                c(
                                    c(
                                      a(str("vni"), arg),
                                      a(str("vni-except"), arg)
                                    ),
                                    c(
                                      a(str("rsvd1"), arg),
                                      a(str("rsvd1-except"), arg)
                                    ),
                                    c(
                                      a(str("rsvd2"), arg),
                                      a(str("rsvd2-except"), arg)
                                    ),
                                    b(str("flags"),
                                      match_flags_value
                                    )
                                )
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              str("accept"),
                              str("discard"),
                              b(str("next"),
                                (str("term"))
                              )
                            ),
                            str("log"),
                            str("pkt-trace"),
                            str("syslog"),
                            a(str("forwarding-class"), arg),
                            a(str("analyzer"), arg),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("next-hop-group"), arg),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("count"), arg),
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("single-packet-rate"), arg),
                                        a(str("two-rate"), arg),
                                        a(str("two-packet-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            a(str("vlan"), arg),
                            b(str("interface"),
                              interface_unit
                            ),
                            b(str("vxlan"),
                                c(
                                    a(str("flags"), arg),
                                    a(str("rsvd1"), arg),
                                    a(str("rsvd2"), arg)
                                )
                            )
                        )
                    ),
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:es_template) do
      b(arg.as(:arg),
        c(
            b(str("attributes"),
                c(
                    b(str("ip-version"),
                        c(
                            b(str("ipv4"),
                                c(
                                    str("destination-port"),
                                    str("destination-prefix-list"),
                                    str("dscp"),
                                    str("fragment-flags"),
                                    str("icmp-code"),
                                    str("icmp-type"),
                                    str("ip-destination-address"),
                                    str("ip-precedence"),
                                    str("ip-protocol"),
                                    str("ip-source-address"),
                                    str("is-fragment"),
                                    str("source-port"),
                                    str("source-prefix-list"),
                                    str("tcp-established"),
                                    str("tcp-flags"),
                                    str("tcp-initial")
                                )
                            ),
                            b(str("ipv6"),
                                c(
                                    str("destination-port"),
                                    str("destination-prefix-list"),
                                    str("icmp-code"),
                                    str("icmp-type"),
                                    str("ip6-destination-address"),
                                    str("ip6-source-address"),
                                    str("next-header"),
                                    str("source-port"),
                                    str("source-prefix-list"),
                                    str("tcp-established"),
                                    str("tcp-flags"),
                                    str("tcp-initial"),
                                    str("traffic-class")
                                )
                            )
                        )
                    ),
                    str("arp-type"),
                    str("destination-mac-address"),
                    str("destination-port"),
                    str("destination-prefix-list"),
                    str("dscp"),
                    str("ether-type"),
                    str("fragment-flags"),
                    str("icmp-code"),
                    str("icmp-type"),
                    str("interface"),
                    str("ip-destination-address"),
                    str("ip-precedence"),
                    str("ip-protocol"),
                    str("ip-source-address"),
                    str("is-fragment"),
                    str("l2-encap-type"),
                    str("learn-vlan-id"),
                    str("source-mac-address"),
                    str("source-port"),
                    str("source-prefix-list"),
                    str("tcp-established"),
                    str("tcp-flags"),
                    str("tcp-initial"),
                    str("user-vlan-1p-priority"),
                    str("user-vlan-id")
                )
            )
        )
      )
    end

    rule(:ethernet_switching_type) do
        c(
            b(str("port-mode"),
              (str("access") | str("tagged-access") | str("trunk"))
            ),
            b(str("interface-mode"),
              (str("access") | str("trunk"))
            ),
            str("inter-switch-link"),
            str("reflective-relay"),
            c(
              b(str("vlan"),
                  c(
                      b(str("members"),
                        (str("all") | arg)
                      )
                  )
              ),
              b(str("inner-vlan"),
                  c(
                      b(str("members"),
                        (str("all") | arg)
                      )
                  )
              ),
              a(str("inner-vlan-id-list"), arg)
            ),
            str("vlan-auto-sense"),
            b(str("bridge-domain-type"),
              (str("svlan") | str("bvlan"))
            ),
            b(str("vlan-rewrite"),
                c(
                    b(a(str("translate"), arg),
                        sc(
                              arg
                        )
                    ).as(:oneline)
                )
            ),
            a(str("native-vlan-id"), arg),
            c(
              b(str("isid-list"),
                (str("all-service-groups") | str("all"))
              )
            ),
            str("core-facing"),
            b(str("filter"),
                c(
                    a(str("input"), arg),
                    a(str("input-precedence"), arg),
                    a(str("input-list"), arg),
                    a(str("output"), arg),
                    a(str("output-precedence"), arg),
                    a(str("output-list"), arg),
                    b(str("adf"),
                        c(
                            a(str("rule"), arg),
                            str("counter"),
                            a(str("input-precedence"), arg),
                            str("not-mandatory"),
                            a(str("output-precedence"), arg)
                        )
                    ),
                    a(str("group"), arg)
                )
            ),
            b(str("policer"),
                c(
                    a(str("input"), arg),
                    a(str("output"), arg)
                )
            ),
            b(str("storm-control"),
                c(
                    arg
                )
            ),
            b(str("recovery-timeout"),
                sc(
                      arg
                )
            ).as(:oneline)
        )
    end

    rule(:ethernet_policer) do
        c(
            c(
              a(str("bandwidth-limit"), arg)
            ),
            a(str("burst-size-limit"), arg)
        )
    end

    rule(:ett_attributes) do
        c(
            b(str("rate"),
              (str("100ge"))
            )
        )
    end

    rule(:family) do
        c(
            b(str("inet"),
                c(
                    c(
                      str("dhcp"),
                      b(str("address"),
                        ipv4prefix
                      )
                    )
                )
            )
        )
    end

    rule(:fibre_channel_type) do
        c(
            b(str("port-mode"),
              (str("f-port") | str("e-port") | str("np-port") | str("auto"))
            ),
            str("no-npiv"),
            b(str("fc-fabric"),
                c(
                    b(str("members"),
                      (str("all") | arg)
                    )
                )
            ),
            a(str("native-fabric"), arg)
        )
    end

    rule(:file_specification_type) do
      b(arg.as(:arg),
        c(
            a(str("name-format"), arg),
            b(str("data-format"),
              (str("flow-compressed"))
            ),
            b(str("transfer"),
                sc(
                    a(str("timeout"), arg),
                    a(str("record-level"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:firewall_addr6_object) do
      b(arg.as(:arg),
        c(
            str("except")
        )
      ).as(:oneline)
    end

    rule(:firewall_addr_object) do
      b(arg.as(:arg),
        c(
            str("except")
        )
      ).as(:oneline)
    end

    rule(:firewall_flexible_match) do
      b(arg.as(:arg),
        c(
            b(str("match-start"),
              (str("layer-2") | str("layer-3") | str("layer-4") | str("payload"))
            ),
            a(str("byte-offset"), arg),
            a(str("bit-offset"), arg),
            a(str("bit-length"), arg)
        )
      )
    end

    rule(:firewall_hierpolicer) do
      b(arg.as(:arg),
        c(
            c(
              str("logical-interface-policer"),
              str("physical-interface-policer")
            ),
            str("shared-bandwidth-policer"),
            str("filter-specific"),
            b(str("aggregate"),
              hierarchical_policer_aggregate_bucket
            ),
            b(str("premium"),
              hierarchical_policer_premium_bucket
            )
        )
      )
    end

    rule(:firewall_load_balance_group) do
      b(arg.as(:arg),
        c(
            a(str("next-hop-group"), arg)
        )
      )
    end

    rule(:firewall_mac_addr_object) do
      b(arg.as(:arg),
        c(
            str("except")
        )
      ).as(:oneline)
    end

    rule(:firewall_policer) do
      b(arg.as(:arg),
        c(
            str("filter-specific"),
            str("logical-interface-policer"),
            str("physical-interface-policer"),
            str("logical-bandwidth-policer"),
            str("shared-bandwidth-policer"),
            c(
              b(str("if-exceeding"),
                  c(
                      c(
                        a(str("bandwidth-limit"), arg),
                        a(str("bandwidth-percent"), arg)
                      ),
                      a(str("burst-size-limit"), arg),
                      b(str("aggregate-policing"),
                          c(
                              b(a(str("policer"), arg),
                                  c(
                                      b(str("aggregate-sharing-mode"),
                                        (str("guarantee") | str("peak"))
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("if-exceeding-pps"),
                  c(
                      c(
                        a(str("pps-limit"), arg)
                      ),
                      a(str("packet-burst"), arg)
                  )
              )
            ),
            b(str("counter"),
                c(
                    a(str("counter-id"), arg)
                )
            ),
            b(str("then"),
                c(
                    str("discard"),
                    b(str("loss-priority"),
                      (str("low") | str("high") | str("medium-low") | str("medium-high"))
                    ),
                    a(str("forwarding-class"), arg),
                    str("out-of-profile")
                )
            ),
            b(str("aggregate"),
                c(
                    c(
                      str("global")
                    )
                )
            )
        )
      )
    end

    rule(:firewall_prefix_list) do
      b(arg.as(:arg),
        c(
            str("except")
        )
      ).as(:oneline)
    end

    rule(:flow_group_type) do
      b(arg.as(:arg),
        c(
            a(str("node-device"), arg),
            a(str("interconnect-device"), arg)
        )
      )
    end

    rule(:fwa_authentication_type) do
        c(
            a(str("password"), arg),
            b(str("username-include"),
                c(
                    a(str("delimiter"), arg),
                    a(str("domain-name"), arg),
                    a(str("user-prefix"), arg),
                    str("imsi"),
                    str("msisdn"),
                    str("mei")
                )
            )
        )
    end

    rule(:gateway_type) do
      b(arg.as(:arg),
        c(
            b(str("service-interface"),
              interface_device
            ),
            b(str("sip"),
                c(
                    b(str("timers"),
                      sip_timers_type
                    ),
                    b(str("new-transaction-policy"),
                      transaction_policy_type
                    ),
                    b(str("new-transaction-policy-set"),
                      new_transaction_set_type
                    ),
                    b(str("new-registration-policy"),
                      registration_policy_type
                    ),
                    b(str("new-registration-policy-set"),
                      new_registration_set_type
                    ),
                    b(str("new-call-usage-policy"),
                      call_usage_policy_type
                    ),
                    b(str("new-call-usage-policy-set"),
                      new_call_usage_set_type
                    ),
                    b(str("routing-destinations"),
                      routing_destinations
                    ),
                    b(str("message-manipulation-rules"),
                      header_manipulation_message_manipulation_rules_type
                    ),
                    a(str("local-tag-prefix"), arg),
                    b(str("signaling-realms"),
                      signaling_realm
                    ),
                    a(str("local-uri-prefix"), arg)
                )
            ),
            b(str("admission-control"),
              admission_control_type
            ),
            b(str("service-point"),
              service_point_type
            ),
            b(str("name-resolution-cache"),
              name_resolution_cache_type
            ),
            b(str("embedded-spdf"),
                c(
                    b(a(str("service-class"), arg),
                        c(
                            b(a(str("term"), arg),
                                c(
                                    b(str("from"),
                                        c(
                                            b(str("media-type"),
                                              (str("any-media") | str("audio") | str("video"))
                                            )
                                        )
                                    ),
                                    b(str("then"),
                                        c(
                                            str("reject"),
                                            b(str("committed-information-rate"),
                                                  enum(arg)
                                            ),
                                            b(str("committed-burst-size"),
                                                  enum(arg)
                                            ),
                                            a(str("dscp"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("flag"),
                        c(
                            b(str("minimum"),
                              (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                            ),
                            b(str("session-trace"),
                              (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                            ),
                            b(str("sip-stack"),
                                c(
                                    str("event-tracing"),
                                    str("ips-tracing"),
                                    str("per-tracing"),
                                    str("dev-logging"),
                                    str("verbose-logging"),
                                    b(str("pd-log-level"),
                                      (str("problem") | str("exception") | str("audit"))
                                    ),
                                    b(str("pd-log-detail"),
                                      (str("full") | str("summary"))
                                    )
                                )
                            ),
                            b(str("signaling"),
                                c(
                                    b(str("minimum"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("sip-stack-wrapper"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("b2b-wrapper"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("ua"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("b2b"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("topology-hiding"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("policy"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("name-resolution-cache"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("accounting-trigger"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("event-trigger"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("packet-capture"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    )
                                )
                            ),
                            b(str("framework"),
                                c(
                                    b(str("minimum"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("executor"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("action"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("event"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("freezer"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("memory-pool"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    )
                                )
                            ),
                            b(str("datastore"),
                                c(
                                    b(str("minimum"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("data"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("handle"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("db"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    )
                                )
                            ),
                            b(str("sbc-utils"),
                                c(
                                    b(str("minimum"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("configuration"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("ipc"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("device-monitor"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("memory-management"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("message"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("common"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("user-interface"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("memory-pool"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    ),
                                    b(str("packet-capture"),
                                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline)
                )
            )
        )
      )
    end

    rule(:admission_control_type) do
      b(arg.as(:arg),
        c(
            b(str("dialogs"),
                c(
                    a(str("maximum-concurrent"), arg),
                    a(str("committed-attempts-rate"), arg),
                    a(str("committed-burst-size"), arg)
                )
            ),
            b(str("transactions"),
                c(
                    a(str("maximum-concurrent"), arg),
                    a(str("committed-attempts-rate"), arg),
                    a(str("committed-burst-size"), arg)
                )
            )
        )
      )
    end

    rule(:call_usage_policy_type) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("source-address"),
                              ipaddr
                            ),
                            b(str("method"),
                              call_usage_method_type
                            ),
                            b(str("request-uri"),
                                c(
                                    b(str("regular-expression"),
                                      regular_expression
                                    )
                                )
                            ),
                            b(str("contact"),
                                c(
                                    b(str("regular-expression"),
                                      regular_expression
                                    )
                                )
                            )
                        )
                    ),
                    b(str("then"),
                      new_call_then_type
                    )
                )
            )
        )
      )
    end

    rule(:call_usage_method_type) do
      enum((str("method-invite"))).as(:arg)
    end

    rule(:ggsn_pgw_apn_services) do
        c(
            b(str("apns"),
                c(
                      ggsn_pgw_apn
                )
            )
        )
    end

    rule(:ggsn_pgw_apn) do
      b(arg.as(:arg),
        c(
            a(str("maximum-bearers"), arg),
            str("wait-accounting"),
            str("block-visitors"),
            str("allow-network-behind-mobile"),
            a(str("local-policy-profile"), arg),
            b(str("apn-type"),
              (str("real") | str("virtual") | str("virtual-pre-authenticate"))
            ),
            a(str("description"), quote | arg),
            b(str("apn-data-type"),
              (str("ipv4") | str("ipv6") | str("ipv4v6"))
            ),
            b(str("mobile-interface"),
              interface_unit
            ),
            b(str("address-assignment"),
                c(
                    c(
                      str("aaa"),
                      b(str("local"),
                          c(
                              str("aaa-override")
                          )
                      ),
                      b(str("dhcp-proxy-client"),
                          c(
                              str("aaa-override")
                          )
                      )
                    ),
                    b(str("inet-pool"),
                        c(
                            a(str("group"), arg),
                            a(str("pool"), arg),
                            a(str("exclude-pools"), arg)
                        )
                    ),
                    b(str("inet6-pool"),
                        c(
                            a(str("group"), arg),
                            a(str("pool"), arg),
                            a(str("exclude-v6pools"), arg)
                        )
                    ),
                    b(str("dhcpv4-proxy-client-profile"),
                        c(
                            a(str("logical-system"), arg),
                            a(str("routing-instance"), arg),
                            a(str("profile-name"), arg),
                            a(str("pool-name"), arg)
                        )
                    ),
                    b(str("dhcpv6-proxy-client-profile"),
                        c(
                            a(str("logical-system"), arg),
                            a(str("routing-instance"), arg),
                            a(str("profile-name"), arg),
                            a(str("pool-name"), arg)
                        )
                    ),
                    b(str("allow-static-ip-address"),
                        c(
                            str("no-aaa-verify")
                        )
                    )
                )
            ),
            a(str("session-timeout"), arg),
            a(str("idle-timeout"), arg),
            b(str("idle-timeout-direction"),
              (str("uplink") | str("both"))
            ),
            a(str("restriction-value"), arg),
            a(str("aaa-profile"), arg),
            b(str("user-options"),
                c(
                    c(
                      a(str("user-name"), arg),
                      str("use-msisdn"),
                      str("use-imsi"),
                      str("use-apnname")
                    ),
                    b(str("password"),
                      unreadable
                    ),
                    str("override-pco")
                )
            ),
            b(str("charging"),
                c(
                    a(str("default-profile"), arg),
                    a(str("home-profile"), arg),
                    a(str("roamer-profile"), arg),
                    a(str("visitor-profile"), arg),
                    b(str("profile-selection-order"),
                      (str("radius") | str("static") | str("serving"))
                    )
                )
            ),
            b(str("dns-server"),
                c(
                    b(str("primary-v4"),
                      ipv4addr
                    ),
                    b(str("secondary-v4"),
                      ipv4addr
                    ),
                    b(str("primary-v6"),
                      ipv6addr
                    ),
                    b(str("secondary-v6"),
                      ipv6addr
                    )
                )
            ),
            b(str("nbns-server"),
                c(
                    b(str("primary-v4"),
                      ipv4addr
                    ),
                    b(str("secondary-v4"),
                      ipv4addr
                    )
                )
            ),
            a(str("p-cscf"), arg),
            b(str("selection-mode"),
                c(
                    str("no-subscribed"),
                    str("from-ms"),
                    str("from-sgsn")
                )
            ),
            a(str("service-selection-profile"), arg),
            b(str("network-behind-mobile"),
                c(
                    b(a(str("imsi"), arg),
                        c(
                            b(str("prefix-v4"),
                              ipv4prefix
                            ),
                            b(str("prefix-v6"),
                              ipv6prefix
                            )
                        )
                    )
                )
            ),
            b(str("service-mode"),
              (str("maintenance"))
            ),
            b(str("call-rate-statistics"),
                c(
                    a(str("interval"), arg),
                    a(str("history"), arg)
                )
            ),
            a(str("pcef-profile"), arg),
            b(str("verify-source-address"),
                c(
                    str("disable")
                )
            ),
            b(str("inter-mobile-traffic"),
                c(
                    b(str("redirect"),
                        c(
                            b(str("redirect-ip"),
                              ipv4addr
                            ),
                            c(
                              a(str("routing-instance"), arg)
                            )
                        )
                    ),
                    str("deny")
                )
            )
        )
      )
    end

    rule(:gtpp_peer) do
      b(arg.as(:arg),
        c(
            b(str("destination-ipv4-address"),
              ipv4addr
            ),
            b(str("source-interface"),
                sc(
                      interface_name,
                    b(str("ipv4-address"),
                      ipv4addr
                    )
                )
            ).as(:oneline),
            a(str("destination-port"), arg),
            b(str("transport-protocol"),
              (str("udp") | str("tcp"))
            ),
            b(str("version"),
              (str("v0") | str("v1") | str("v2"))
            ),
            a(str("echo-interval"), arg),
            a(str("n3-requests"), arg),
            a(str("t3-response"), arg),
            b(str("header-type"),
              (str("short") | str("long"))
            ),
            a(str("pending-queue-size"), arg),
            a(str("down-detect-time"), arg),
            a(str("reconnect-time"), arg),
            str("no-path-management")
        )
      )
    end

    rule(:hcm_tag_rule_object) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      hcm_tag_match_object
                    ),
                    b(str("then"),
                        c(
                            b(a(str("tag"), arg),
                                c(
                                    a(str("tag-header"), arg),
                                    str("do-not-rename-existing-tag-header"),
                                    a(str("tag-separator"), arg),
                                    b(str("tag-attribute"),
                                          (str("msisdn") | str("imsi") | str("apn") | str("imei") | str("ipv4addr") | str("ipv6addr") | str("ggsnipv4") | str("ggsnipv6") | str("radiusclass"))
                                    ),
                                    b(str("encrypt"),
                                        c(
                                            b(str("hash"),
                                              (str("md5"))
                                            ),
                                            a(str("prefix"), arg)
                                        )
                                    ),
                                    b(str("ipv4-mask"),
                                      ipv4addr
                                    ),
                                    b(str("ipv4-or-value"),
                                      ipv4addr
                                    ),
                                    b(str("ipv6-mask"),
                                      ipv6addr
                                    ),
                                    b(str("ipv6-or-value"),
                                      ipv6addr
                                    )
                                )
                            ),
                            str("count")
                        )
                    )
                )
            )
        )
      )
    end

    rule(:hcm_tag_match_object) do
        c(
            b(str("destination-address"),
              sfw_addr_object
            ),
            b(str("destination-address-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg),
                  c(
                    str("except")
                  )
                )
            ).as(:oneline),
            b(a(str("destination-prefix-list"), arg),
                sc(
                    str("except")
                )
            ).as(:oneline),
            a(str("destination-ports"), arg),
            b(str("destination-port-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg)
                )
            ).as(:oneline)
        )
    end

    rule(:hcm_url_list_object) do
      b(arg.as(:arg),
        c(
            a(str("host"), arg),
            a(str("request-uri"), arg)
        )
      )
    end

    rule(:hcm_url_rule_object) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      hcm_url_match_object
                    ),
                    b(str("then"),
                        c(
                            str("count"),
                            str("log-request"),
                            c(
                              str("accept"),
                              str("discard")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:hcm_url_match_object) do
        c(
            a(str("url-list"), arg),
            b(a(str("url"), arg),
                c(
                    a(str("host"), arg),
                    a(str("request-uri"), arg)
                )
            )
        )
    end

    rule(:header_manipulation_message_manipulation_rules_type) do
        c(
            b(str("manipulation-rule"),
              header_manipulation_manipulation_rule_type
            )
        )
    end

    rule(:header_manipulation_manipulation_rule_type) do
      b(arg.as(:arg),
        c(
            b(str("actions"),
              header_manipulation_actions_type
            )
        )
      )
    end

    rule(:header_manipulation_actions_type) do
        c(
            b(a(str("sip-header"), arg),
                c(
                    b(str("field-value"),
                      header_manipulation_sip_header_field_value_type
                    )
                )
            ),
            b(str("request-uri"),
                c(
                    b(str("field-value"),
                        c(
                            b(str("modify-regular-expression"),
                              header_manipulation_modify_type
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:header_manipulation_modify_type) do
      b(arg.as(:arg),
        c(
            a(str("with"), arg)
        )
      ).as(:oneline)
    end

    rule(:header_manipulation_sip_header_field_value_type) do
        c(
            str("remove-all"),
            b(str("remove-regular-expression"),
              header_manipulation_remove_type
            ),
            b(str("reject-regular-expression"),
              header_manipulation_reject_type
            ),
            b(str("modify-regular-expression"),
              header_manipulation_modify_type
            ),
            b(str("add"),
              header_manipulation_add_type
            ),
            b(str("add-missing"),
              header_manipulation_add_missing_type
            ),
            b(str("add-overwrite"),
              header_manipulation_add_overwrite_type
            )
        )
    end

    rule(:header_manipulation_add_missing_type) do
      arg.as(:arg).as(:oneline)
    end

    rule(:header_manipulation_add_overwrite_type) do
      arg.as(:arg).as(:oneline)
    end

    rule(:header_manipulation_add_type) do
      arg.as(:arg).as(:oneline)
    end

    rule(:header_manipulation_reject_type) do
      arg.as(:arg).as(:oneline)
    end

    rule(:header_manipulation_remove_type) do
      arg.as(:arg).as(:oneline)
    end

    rule(:hierarchical_policer_aggregate_bucket) do
        c(
            c(
              b(str("if-exceeding"),
                  c(
                      c(
                        a(str("bandwidth-limit"), arg)
                      ),
                      a(str("burst-size-limit"), arg)
                  )
              ),
              b(str("if-exceeding-pps"),
                  c(
                      c(
                        a(str("pps-limit"), arg)
                      ),
                      a(str("packet-burst"), arg)
                  )
              )
            ),
            b(str("then"),
                c(
                    c(
                      str("discard"),
                      b(str("loss-priority"),
                        (str("low") | str("high") | str("medium-low") | str("medium-high"))
                      ),
                      a(str("forwarding-class"), arg)
                    )
                )
            )
        )
    end

    rule(:hierarchical_policer_premium_bucket) do
        c(
            c(
              b(str("if-exceeding"),
                  c(
                      c(
                        a(str("bandwidth-limit"), arg)
                      ),
                      a(str("burst-size-limit"), arg)
                  )
              ),
              b(str("if-exceeding-pps"),
                  c(
                      c(
                        a(str("pps-limit"), arg)
                      ),
                      a(str("packet-burst"), arg)
                  )
              )
            ),
            b(str("then"),
                c(
                    c(
                      str("discard")
                    )
                )
            )
        )
    end

    rule(:hybrid_access_tunnel_group_object) do
      b(arg.as(:arg),
        c(
            b(str("source-address"),
              ipaddr
            ),
            c(
              b(str("service-interface"),
                interface_unit
              ),
              a(str("service-device-pool"), arg)
            ),
            a(str("dynamic-profile"), arg),
            a(str("password"), arg),
            a(str("tunnel-hello-interval"), arg),
            a(str("tunnel-idle-timeout"), arg),
            a(str("tunnel-routing-instance"), arg),
            b(str("destination-networks"),
              hybrid_access_dest_network_object
            ),
            b(str("round-trip-time-difference-threshold"),
                c(
                    a(str("time"), arg),
                    a(str("violation-count"), arg),
                    a(str("compliance-count"), arg)
                )
            ),
            b(str("access-line"),
                c(
                    b(str("link-type"),
                        c(
                            b(str("dsl"),
                                c(
                                    a(str("dynamic-profile"), arg),
                                    a(str("max-links"), arg),
                                    a(str("tunnel-hello-interval"), arg),
                                    a(str("tunnel-idle-timeout"), arg),
                                    a(str("upstream-bandwidth"), arg),
                                    a(str("downstream-bandwidth"), arg)
                                )
                            ),
                            b(str("lte"),
                                c(
                                    a(str("dynamic-profile"), arg),
                                    a(str("max-links"), arg),
                                    a(str("tunnel-hello-interval"), arg),
                                    a(str("tunnel-idle-timeout"), arg),
                                    a(str("upstream-bandwidth"), arg),
                                    a(str("downstream-bandwidth"), arg)
                                )
                            ),
                            b(str("other"),
                                c(
                                    a(str("dynamic-profile"), arg),
                                    a(str("max-links"), arg),
                                    a(str("tunnel-hello-interval"), arg),
                                    a(str("tunnel-idle-timeout"), arg),
                                    a(str("upstream-bandwidth"), arg),
                                    a(str("downstream-bandwidth"), arg)
                                )
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:hybrid_access_dest_network_object) do
      arg.as(:arg)
    end

    rule(:idp_policy_type) do
      b(arg.as(:arg),
        c(
            b(str("rulebase-ips"),
                c(
                    b(a(str("rule"), arg),
                        c(
                            a(str("description"), quote | arg),
                            b(str("match"),
                                c(
                                    b(str("from-zone"),
                                      (str("any") | arg)
                                    ),
                                    c(
                                      b(str("source-address"),
                                        (str("any") | str("any-ipv4") | str("any-ipv6") | arg)
                                      ),
                                      b(str("source-except"),
                                        (arg)
                                      ),
                                      b(str("source-prefix"),
                                        ipv4prefix
                                      ),
                                      b(str("source-prefix-except"),
                                        ipv4prefix
                                      )
                                    ),
                                    b(str("to-zone"),
                                      (str("any") | arg)
                                    ),
                                    c(
                                      b(str("destination-address"),
                                        (str("any") | str("any-ipv4") | str("any-ipv6") | arg)
                                      ),
                                      b(str("destination-except"),
                                        (arg)
                                      ),
                                      b(str("destination-prefix"),
                                        ipv4prefix
                                      ),
                                      b(str("destination-prefix-except"),
                                        ipv4prefix
                                      )
                                    ),
                                    b(str("application"),
                                      (str("any") | str("default") | arg)
                                    ),
                                    b(str("attacks"),
                                        c(
                                            a(str("custom-attacks"), arg),
                                            a(str("custom-attack-groups"), arg),
                                            a(str("dynamic-attack-groups"), arg),
                                            a(str("predefined-attacks"), arg),
                                            a(str("predefined-attack-groups"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("then"),
                                c(
                                    b(str("action"),
                                        c(
                                            c(
                                              str("no-action"),
                                              str("ignore-connection"),
                                              b(str("mark-diffserv"),
                                                  c(
                                                        arg
                                                  )
                                              ),
                                              b(str("class-of-service"),
                                                  c(
                                                      a(str("forwarding-class"), arg),
                                                      a(str("dscp-code-point"), arg)
                                                  )
                                              ),
                                              str("drop-packet"),
                                              str("drop-connection"),
                                              str("close-client"),
                                              str("close-server"),
                                              str("close-client-and-server"),
                                              str("recommended")
                                            )
                                        )
                                    ),
                                    b(str("ip-action"),
                                        c(
                                            c(
                                              str("ip-notify"),
                                              str("ip-close"),
                                              str("ip-block")
                                            ),
                                            b(str("target"),
                                              (str("service") | str("source-zone-address") | str("source-address") | str("destination-address") | str("zone-service") | str("source-zone"))
                                            ),
                                            str("log"),
                                            str("log-create"),
                                            a(str("timeout"), arg),
                                            str("refresh-timeout")
                                        )
                                    ),
                                    b(str("notification"),
                                        c(
                                            b(str("log-attacks"),
                                                c(
                                                    str("alert")
                                                )
                                            ),
                                            b(str("packet-log"),
                                                c(
                                                    a(str("pre-attack"), arg),
                                                    a(str("post-attack"), arg),
                                                    a(str("post-attack-timeout"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("severity"),
                                      (str("info") | str("warning") | str("minor") | str("major") | str("critical"))
                                    )
                                )
                            ),
                            str("terminal")
                        )
                    )
                )
            ),
            b(str("rulebase-exempt"),
                c(
                    b(a(str("rule"), arg),
                        c(
                            a(str("description"), quote | arg),
                            b(str("match"),
                                c(
                                    b(str("from-zone"),
                                      (str("any") | arg)
                                    ),
                                    c(
                                      b(str("source-address"),
                                        (str("any") | str("any-ipv4") | str("any-ipv6") | arg)
                                      ),
                                      b(str("source-except"),
                                        (arg)
                                      ),
                                      b(str("source-prefix"),
                                        ipv4prefix
                                      ),
                                      b(str("source-prefix-except"),
                                        ipv4prefix
                                      )
                                    ),
                                    b(str("to-zone"),
                                      (str("any") | arg)
                                    ),
                                    c(
                                      b(str("destination-address"),
                                        (str("any") | str("any-ipv4") | str("any-ipv6") | arg)
                                      ),
                                      b(str("destination-except"),
                                        (arg)
                                      ),
                                      b(str("destination-prefix"),
                                        ipv4prefix
                                      ),
                                      b(str("destination-prefix-except"),
                                        ipv4prefix
                                      )
                                    ),
                                    b(str("attacks"),
                                        c(
                                            a(str("custom-attacks"), arg),
                                            a(str("custom-attack-groups"), arg),
                                            a(str("dynamic-attack-groups"), arg),
                                            a(str("predefined-attacks"), arg),
                                            a(str("predefined-attack-groups"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:idpd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("all"))).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            )
        )
    end

    rule(:ids_rule_object) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("input") | str("output") | str("input-output"))
            ),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      sfw_match_object
                    ),
                    b(str("then"),
                        c(
                            c(
                              str("force-entry"),
                              str("ignore-entry"),
                              b(str("user-interface"),
                                (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                              )
                            ),
                            b(str("aggregation"),
                                c(
                                    a(str("source-prefix"), arg),
                                    a(str("destination-prefix"), arg),
                                    a(str("source-prefix-ipv6"), arg),
                                    a(str("destination-prefix-ipv6"), arg)
                                )
                            ),
                            b(str("logging"),
                                c(
                                    a(str("threshold"), arg),
                                    str("syslog")
                                )
                            ),
                            b(str("syn-cookie"),
                                c(
                                    a(str("threshold"), arg),
                                    a(str("mss"), arg)
                                )
                            ),
                            b(str("session-limit"),
                                c(
                                    b(str("by-source"),
                                      ids_limit_type
                                    ),
                                    b(str("by-destination"),
                                      ids_limit_type
                                    ),
                                    b(str("by-pair"),
                                      ids_limit_type
                                    )
                                )
                            ),
                            b(str("allow-ip-options"),
                                  (str("any") | str("strict-source-route") | str("loose-source-route") | str("route-record") | str("timestamp") | str("router-alert") | str("security") | str("stream-id") | arg)
                            ),
                            b(str("allow-ipv6-extension-header"),
                                  (str("any") | str("hop-by-hop") | str("routing") | str("mobility") | str("esp") | str("fragment") | str("dstopts") | str("ah") | arg)
                            ),
                            str("tcp-syn-defense"),
                            str("tcp-syn-fragment-check"),
                            str("tcp-winnuke-check"),
                            str("icmp-fragment-check"),
                            str("icmp-large-packet-check"),
                            b(str("land-attack-check"),
                              (str("ip-only") | str("ip-port"))
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:ids_limit_type) do
        c(
            a(str("maximum"), arg),
            a(str("rate"), arg),
            a(str("packets"), arg),
            a(str("hold-time"), arg),
            b(str("by-protocol"),
                c(
                    b(str("tcp"),
                      ids_proto_limit_type
                    ),
                    b(str("udp"),
                      ids_proto_limit_type
                    ),
                    b(str("icmp"),
                      ids_proto_limit_type
                    )
                )
            )
        )
    end

    rule(:ids_proto_limit_type) do
        c(
            a(str("maximum"), arg),
            a(str("rate"), arg),
            a(str("packets"), arg)
        )
    end

    rule(:inet6_dialer_filter) do
      b(arg.as(:arg),
        c(
            a(str("accounting-profile"), arg),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("source-address"),
                              firewall_addr6_object
                            ),
                            b(str("destination-address"),
                              firewall_addr6_object
                            ),
                            b(str("address"),
                              firewall_addr6_object
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              a(str("packet-length"), arg),
                              a(str("packet-length-except"), arg)
                            ),
                            c(
                              b(str("next-header"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("next-header-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-type"),
                                    (str("destination-unreachable") | str("packet-too-big") | str("time-exceeded") | str("parameter-problem") | str("echo-request") | str("echo-reply") | str("membership-query") | str("membership-report") | str("membership-termination") | str("router-solicit") | str("router-advertisement") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | str("inverse-neighbor-discovery-solicitation") | str("inverse-neighbor-discovery-advertisement") | str("home-agent-address-discovery-request") | str("home-agent-address-discovery-reply") | str("mobile-prefix-solicitation") | str("mobile-prefix-advertisement-reply") | str("certificate-path-solicitation") | str("certificate-path-advertisement") | str("private-experimentation-100") | str("private-experimentation-101") | str("private-experimentation-200") | str("private-experimentation-201") | arg)
                              ),
                              b(str("icmp-type-except"),
                                    (str("destination-unreachable") | str("packet-too-big") | str("time-exceeded") | str("parameter-problem") | str("echo-request") | str("echo-reply") | str("membership-query") | str("membership-report") | str("membership-termination") | str("router-solicit") | str("router-advertisement") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | str("inverse-neighbor-discovery-solicitation") | str("inverse-neighbor-discovery-advertisement") | str("home-agent-address-discovery-request") | str("home-agent-address-discovery-reply") | str("mobile-prefix-solicitation") | str("mobile-prefix-advertisement-reply") | str("certificate-path-solicitation") | str("certificate-path-advertisement") | str("private-experimentation-100") | str("private-experimentation-101") | str("private-experimentation-200") | str("private-experimentation-201") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-code"),
                                    (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
                              ),
                              b(str("icmp-code-except"),
                                    (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            str("log"),
                            str("syslog"),
                            str("sample"),
                            c(
                              str("note"),
                              str("ignore")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet6_filter) do
      b(arg.as(:arg),
        c(
            b(str("promote"),
              (str("gre-key") | str("traffic-class"))
            ),
            a(str("accounting-profile"), arg),
            str("interface-specific"),
            str("scale-optimized"),
            str("enhanced-mode"),
            str("interface-shared"),
            str("enhanced-mode-override"),
            str("physical-interface-filter"),
            str("fast-lookup-filter"),
            str("instance-shared"),
            b(a(str("term"), arg),
                c(
                    a(str("filter"), arg),
                    b(str("from"),
                        c(
                            c(
                              a(str("destination-class"), arg),
                              a(str("destination-class-except"), arg)
                            ),
                            c(
                              a(str("source-class"), arg),
                              a(str("source-class-except"), arg)
                            ),
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            b(str("source-address"),
                              firewall_addr6_object
                            ),
                            b(str("destination-address"),
                              firewall_addr6_object
                            ),
                            b(str("address"),
                              firewall_addr6_object
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              b(str("next-header"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("next-header-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("payload-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("payload-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("extension-header"),
                                    (str("any") | str("hop-by-hop") | str("routing") | str("mobility") | str("esp") | str("fragment") | str("dstopts") | str("ah") | arg)
                              ),
                              b(str("extension-header-except"),
                                    (str("any") | str("hop-by-hop") | str("routing") | str("mobility") | str("esp") | str("fragment") | str("dstopts") | str("ah") | arg)
                              )
                            ),
                            c(
                              a(str("packet-length"), arg),
                              a(str("packet-length-except"), arg)
                            ),
                            c(
                              b(str("traffic-class"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("traffic-class-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-type"),
                                    (str("destination-unreachable") | str("packet-too-big") | str("time-exceeded") | str("parameter-problem") | str("echo-request") | str("echo-reply") | str("membership-query") | str("membership-report") | str("membership-termination") | str("router-solicit") | str("router-advertisement") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | str("inverse-neighbor-discovery-solicitation") | str("inverse-neighbor-discovery-advertisement") | str("home-agent-address-discovery-request") | str("home-agent-address-discovery-reply") | str("mobile-prefix-solicitation") | str("mobile-prefix-advertisement-reply") | str("certificate-path-solicitation") | str("certificate-path-advertisement") | str("private-experimentation-100") | str("private-experimentation-101") | str("private-experimentation-200") | str("private-experimentation-201") | arg)
                              ),
                              b(str("icmp-type-except"),
                                    (str("destination-unreachable") | str("packet-too-big") | str("time-exceeded") | str("parameter-problem") | str("echo-request") | str("echo-reply") | str("membership-query") | str("membership-report") | str("membership-termination") | str("router-solicit") | str("router-advertisement") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | str("inverse-neighbor-discovery-solicitation") | str("inverse-neighbor-discovery-advertisement") | str("home-agent-address-discovery-request") | str("home-agent-address-discovery-reply") | str("mobile-prefix-solicitation") | str("mobile-prefix-advertisement-reply") | str("certificate-path-solicitation") | str("certificate-path-advertisement") | str("private-experimentation-100") | str("private-experimentation-101") | str("private-experimentation-200") | str("private-experimentation-201") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-code"),
                                    (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
                              ),
                              b(str("icmp-code-except"),
                                    (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
                              )
                            ),
                            str("tcp-initial"),
                            str("tcp-established"),
                            a(str("tcp-flags"), arg),
                            b(str("interface"),
                              match_interface_object
                            ),
                            b(str("interface-set"),
                              match_interface_set_object
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            str("service-filter-hit"),
                            c(
                              a(str("hop-limit"), arg),
                              a(str("hop-limit-except"), arg)
                            ),
                            str("is-fragment"),
                            str("egress-to-ingress"),
                            str("first-fragment"),
                            str("last-fragment"),
                            c(
                              b(str("flexible-match-mask"),
                                match_l3_flexible_mask
                              )
                            ),
                            c(
                              b(str("flexible-match-range"),
                                match_l3_flexible_range
                              )
                            ),
                            c(
                              a(str("gre-key"), arg),
                              a(str("gre-key-except"), arg)
                            ),
                            c(
                              a(str("policy-map"), arg),
                              a(str("policy-map-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("single-packet-rate"), arg),
                                        a(str("two-rate"), arg),
                                        a(str("two-packet-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            c(
                              str("clear-policy-map"),
                              a(str("policy-map"), arg)
                            ),
                            c(
                              a(str("traffic-class-count"), arg),
                              a(str("count"), arg)
                            ),
                            str("service-accounting"),
                            str("service-accounting-deferred"),
                            str("log"),
                            str("pkt-trace"),
                            str("syslog"),
                            str("sample"),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("analyzer"), arg),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("forwarding-class"), arg),
                            b(str("traffic-class"),
                              (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                            ),
                            str("skip-services"),
                            str("service-filter-hit"),
                            str("force-premium"),
                            str("exclude-accounting"),
                            c(
                              b(str("decapsulate"),
                                  sc(
                                      c(
                                        b(str("gre"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                c(
                                                  b(str("routing-instance"),
                                                      sc(
                                                          arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ),
                                        b(str("gre-in-udp"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                c(
                                                  b(str("routing-instance"),
                                                      sc(
                                                          arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ),
                                        b(str("mpls-in-udp"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                c(
                                                  b(str("routing-instance"),
                                                      sc(
                                                          arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ),
                                        b(str("l2tp"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                a(str("cookie"), arg),
                                                c(
                                                  b(str("output-interface"),
                                                    interface_unit
                                                  )
                                                )
                                            )
                                        ),
                                        b(str("ipip"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                c(
                                                  b(str("routing-instance"),
                                                      sc(
                                                          arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("encapsulate"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline),
                              str("accept"),
                              str("discard"),
                              b(str("next"),
                                (str("term"))
                              ),
                              a(str("next-hop-group"), arg),
                              b(str("logical-system"),
                                  s(
                                          arg,
                                    c(
                                      b(str("routing-instance"),
                                          sc(
                                              arg,
                                              a(str("topology"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("topology"), arg)
                                    )
                                  )
                              ).as(:oneline),
                              b(str("routing-instance"),
                                  sc(
                                      arg,
                                      a(str("topology"), arg)
                                  )
                              ).as(:oneline),
                              a(str("topology"), arg),
                              b(str("next-ip6"),
                                  sc(
                                        ipv6prefix,
                                      b(str("routing-instance"),
                                          sc(
                                              arg,
                                              a(str("topology"), arg)
                                          )
                                      ).as(:oneline)
                                  )
                              ).as(:oneline),
                              b(str("next-interface"),
                                  ca(
                                      b(str("routing-instance"),
                                          sc(
                                              arg,
                                              a(str("topology"), arg)
                                          )
                                      ).as(:oneline),
                                      c(
                                        str("accept"),
                                        b(str("next"),
                                          (str("term"))
                                        )
                                      )
                                  )
                              ),
                              b(str("reject"),
                                  sc(
                                      c(
                                        str("no-route"),
                                        str("administratively-prohibited"),
                                        str("beyond-scope"),
                                        str("address-unreachable"),
                                        str("port-unreachable"),
                                        str("policy-failed"),
                                        str("reject-route"),
                                        str("tcp-reset"),
                                        str("network-unreachable"),
                                        str("host-unreachable"),
                                        str("protocol-unreachable"),
                                        str("source-route-failed"),
                                        str("network-unknown"),
                                        str("host-unknown"),
                                        str("source-host-isolated"),
                                        str("network-prohibited"),
                                        str("host-prohibited"),
                                        str("bad-network-tos"),
                                        str("bad-host-tos"),
                                        str("precedence-violation"),
                                        str("precedence-cutoff")
                                      )
                                  )
                              ).as(:oneline)
                            )
                        )
                    ),
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet6_fuf) do
      b(arg.as(:arg),
        c(
            str("interface-specific"),
            b(str("match-order"),
                  (str("next-header") | str("payload-protocol") | str("source-address") | str("destination-address") | str("source-port") | str("destination-port") | str("traffic-class"))
            ),
            b(a(str("term"), arg),
                c(
                    str("only-at-create"),
                    b(str("from"),
                        c(
                            b(str("source-address"),
                              firewall_addr6_simple_object
                            ),
                            b(str("destination-address"),
                              firewall_addr6_simple_object
                            ),
                            c(
                              b(str("source-port"),
                                match_simple_port_value
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                match_simple_port_value
                              )
                            ),
                            c(
                              b(str("next-header"),
                                match_simple_protocol_value
                              )
                            ),
                            c(
                              b(str("payload-protocol"),
                                match_simple_payload_protocol_value
                              )
                            ),
                            c(
                              b(str("traffic-class"),
                                match_simple_dscp_value
                              )
                            ),
                            a(str("match-terms"), arg)
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg)
                            ),
                            a(str("count"), arg),
                            str("service-accounting"),
                            str("log"),
                            str("port-mirror"),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("forwarding-class"), arg),
                            a(str("action-terms"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              b(str("routing-instance"),
                                  sc(
                                      arg,
                                      a(str("topology"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:firewall_addr6_simple_object) do
        c(
              ipv6prefix
        )
    end

    rule(:inet6_service_filter) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            b(str("source-address"),
                              firewall_addr6_object
                            ),
                            b(str("destination-address"),
                              firewall_addr6_object
                            ),
                            b(str("address"),
                              firewall_addr6_object
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              b(str("next-header"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("next-header-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("payload-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("payload-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("extension-header"),
                                    (str("any") | str("hop-by-hop") | str("routing") | str("mobility") | str("esp") | str("fragment") | str("dstopts") | str("ah") | arg)
                              ),
                              b(str("extension-header-except"),
                                    (str("any") | str("hop-by-hop") | str("routing") | str("mobility") | str("esp") | str("fragment") | str("dstopts") | str("ah") | arg)
                              )
                            ),
                            c(
                              a(str("esp-spi"), arg),
                              a(str("esp-spi-except"), arg)
                            ),
                            c(
                              a(str("ah-spi"), arg),
                              a(str("ah-spi-except"), arg)
                            ),
                            a(str("tcp-flags"), arg),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            a(str("count"), arg),
                            str("log"),
                            str("pkt-trace"),
                            str("sample"),
                            str("port-mirror"),
                            c(
                              str("service"),
                              str("skip"),
                              str("accept")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet6_template) do
      b(arg.as(:arg),
        c(
            b(str("attributes"),
                c(
                    str("destination-address"),
                    str("destination-port"),
                    str("destination-prefix-list"),
                    str("flexible-match-mask"),
                    str("flexible-match-range"),
                    str("hop-limit"),
                    str("icmp-code"),
                    str("icmp-type"),
                    str("interface"),
                    str("next-header"),
                    str("source-address"),
                    str("source-port"),
                    str("source-prefix-list"),
                    str("tcp-established"),
                    str("tcp-flags"),
                    str("tcp-initial"),
                    str("traffic-class"),
                    str("egress-to-ingress")
                )
            )
        )
      )
    end

    rule(:inet_dialer_filter) do
      b(arg.as(:arg),
        c(
            a(str("accounting-profile"), arg),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("source-address"),
                              firewall_addr_object
                            ),
                            b(str("destination-address"),
                              firewall_addr_object
                            ),
                            b(str("address"),
                              firewall_addr_object
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              a(str("packet-length"), arg),
                              a(str("packet-length-except"), arg)
                            ),
                            c(
                              b(str("precedence"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              ),
                              b(str("precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              )
                            ),
                            c(
                              b(str("dscp"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("dscp-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            c(
                              b(str("ip-options"),
                                    (str("any") | str("strict-source-route") | str("loose-source-route") | str("route-record") | str("timestamp") | str("router-alert") | str("security") | str("stream-id") | arg)
                              ),
                              b(str("ip-options-except"),
                                    (str("any") | str("strict-source-route") | str("loose-source-route") | str("route-record") | str("timestamp") | str("router-alert") | str("security") | str("stream-id") | arg)
                              )
                            ),
                            str("is-fragment"),
                            str("first-fragment"),
                            c(
                              a(str("fragment-offset"), arg),
                              a(str("fragment-offset-except"), arg)
                            ),
                            a(str("fragment-flags"), arg),
                            c(
                              b(str("protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              a(str("ttl"), arg),
                              a(str("ttl-except"), arg)
                            ),
                            c(
                              b(str("icmp-type"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              ),
                              b(str("icmp-type-except"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-code"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              ),
                              b(str("icmp-code-except"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            str("tcp-initial"),
                            str("tcp-established"),
                            a(str("tcp-flags"), arg),
                            c(
                              a(str("esp-spi"), arg),
                              a(str("esp-spi-except"), arg)
                            ),
                            c(
                              a(str("ah-spi"), arg),
                              a(str("ah-spi-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            str("log"),
                            str("syslog"),
                            str("sample"),
                            c(
                              str("note"),
                              str("ignore")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet_filter) do
      b(arg.as(:arg),
        c(
            b(str("promote"),
              (str("gre-key") | str("dscp"))
            ),
            a(str("accounting-profile"), arg),
            str("interface-specific"),
            str("scale-optimized"),
            str("physical-interface-filter"),
            str("enhanced-mode"),
            str("interface-shared"),
            str("enhanced-mode-override"),
            str("instance-shared"),
            str("fast-lookup-filter"),
            b(a(str("term"), arg),
                c(
                    a(str("filter"), arg),
                    b(str("from"),
                        c(
                            c(
                              a(str("destination-class"), arg),
                              a(str("destination-class-except"), arg)
                            ),
                            c(
                              a(str("source-class"), arg),
                              a(str("source-class-except"), arg)
                            ),
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            b(str("source-address"),
                              firewall_addr_object
                            ),
                            b(str("destination-address"),
                              firewall_addr_object
                            ),
                            b(str("address"),
                              firewall_addr_object
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              a(str("packet-length"), arg),
                              a(str("packet-length-except"), arg)
                            ),
                            c(
                              b(str("dscp"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("dscp-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            c(
                              b(str("precedence"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              ),
                              b(str("precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              )
                            ),
                            c(
                              b(str("ip-options"),
                                    (str("any") | str("strict-source-route") | str("loose-source-route") | str("route-record") | str("timestamp") | str("router-alert") | str("security") | str("stream-id") | arg)
                              ),
                              b(str("ip-options-except"),
                                    (str("any") | str("strict-source-route") | str("loose-source-route") | str("route-record") | str("timestamp") | str("router-alert") | str("security") | str("stream-id") | arg)
                              )
                            ),
                            str("is-fragment"),
                            str("egress-to-ingress"),
                            str("first-fragment"),
                            str("service-filter-hit"),
                            c(
                              a(str("fragment-offset"), arg),
                              a(str("fragment-offset-except"), arg)
                            ),
                            a(str("fragment-flags"), arg),
                            c(
                              b(str("protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              a(str("ttl"), arg),
                              a(str("ttl-except"), arg)
                            ),
                            c(
                              b(str("icmp-type"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              ),
                              b(str("icmp-type-except"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-code"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              ),
                              b(str("icmp-code-except"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            str("tcp-initial"),
                            str("tcp-established"),
                            a(str("tcp-flags"), arg),
                            c(
                              a(str("esp-spi"), arg),
                              a(str("esp-spi-except"), arg)
                            ),
                            c(
                              a(str("ah-spi"), arg),
                              a(str("ah-spi-except"), arg)
                            ),
                            b(str("interface"),
                              match_interface_object
                            ),
                            b(str("interface-set"),
                              match_interface_set_object
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            str("source-port-range-optimize"),
                            str("destination-port-range-optimize"),
                            c(
                              b(str("rat-type"),
                                    (str("geran") | str("utran") | str("eutran") | arg)
                              ),
                              b(str("rat-type-except"),
                                    (str("geran") | str("utran") | str("eutran") | arg)
                              )
                            ),
                            c(
                              b(str("redirect-reason"),
                                    (str("aoc") | str("aolb") | str("dpi"))
                              ),
                              b(str("redirect-reason-except"),
                                    (str("aoc") | str("aolb") | str("dpi"))
                              )
                            ),
                            c(
                              a(str("gre-key"), arg),
                              a(str("gre-key-except"), arg)
                            ),
                            c(
                              b(str("flexible-match-mask"),
                                match_l3_flexible_mask
                              )
                            ),
                            c(
                              b(str("flexible-match-range"),
                                match_l3_flexible_range
                              )
                            ),
                            c(
                              a(str("policy-map"), arg),
                              a(str("policy-map-except"), arg)
                            ),
                            b(str("vxlan"),
                                c(
                                    c(
                                      a(str("vni"), arg),
                                      a(str("vni-except"), arg)
                                    ),
                                    c(
                                      a(str("rsvd1"), arg),
                                      a(str("rsvd1-except"), arg)
                                    ),
                                    c(
                                      a(str("rsvd2"), arg),
                                      a(str("rsvd2-except"), arg)
                                    ),
                                    b(str("flags"),
                                      match_flags_value
                                    )
                                )
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("single-packet-rate"), arg),
                                        a(str("two-rate"), arg),
                                        a(str("two-packet-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            c(
                              str("clear-policy-map"),
                              a(str("policy-map"), arg)
                            ),
                            c(
                              a(str("traffic-class-count"), arg),
                              a(str("count"), arg)
                            ),
                            str("service-accounting"),
                            str("skip-services"),
                            str("service-accounting-deferred"),
                            str("log"),
                            str("pkt-trace"),
                            str("packet-mode"),
                            str("syslog"),
                            str("sample"),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("analyzer"), arg),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("forwarding-class"), arg),
                            str("service-filter-hit"),
                            str("force-premium"),
                            str("exclude-accounting"),
                            a(str("virtual-channel"), arg),
                            c(
                              str("accept"),
                              b(str("discard"),
                                  c(
                                      a(str("accounting"), arg)
                                  )
                              ),
                              b(str("next"),
                                (str("term"))
                              ),
                              b(str("logical-system"),
                                  s(
                                          arg,
                                    c(
                                      b(str("routing-instance"),
                                          sc(
                                              arg,
                                              a(str("topology"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("topology"), arg)
                                    )
                                  )
                              ).as(:oneline),
                              b(str("routing-instance"),
                                  sc(
                                      arg,
                                      a(str("topology"), arg)
                                  )
                              ).as(:oneline),
                              a(str("topology"), arg),
                              b(str("next-ip"),
                                  sc(
                                        ipv4prefix,
                                      b(str("routing-instance"),
                                          sc(
                                              arg,
                                              a(str("topology"), arg)
                                          )
                                      ).as(:oneline)
                                  )
                              ).as(:oneline),
                              b(str("next-interface"),
                                  ca(
                                      b(str("routing-instance"),
                                          sc(
                                              arg,
                                              a(str("topology"), arg)
                                          )
                                      ).as(:oneline),
                                      c(
                                        str("accept"),
                                        b(str("next"),
                                          (str("term"))
                                        )
                                      )
                                  )
                              ),
                              a(str("ipsec-sa"), arg),
                              a(str("next-hop-group"), arg),
                              b(str("decapsulate"),
                                  sc(
                                      c(
                                        b(str("gre"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                c(
                                                  b(str("routing-instance"),
                                                      sc(
                                                          arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ),
                                        b(str("gre-in-udp"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                c(
                                                  b(str("routing-instance"),
                                                      sc(
                                                          arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ),
                                        b(str("mpls-in-udp"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                c(
                                                  b(str("routing-instance"),
                                                      sc(
                                                          arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        ),
                                        b(str("l2tp"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                a(str("cookie"), arg),
                                                c(
                                                  b(str("output-interface"),
                                                    interface_unit
                                                  )
                                                )
                                            )
                                        ),
                                        b(str("ipip"),
                                            c(
                                                b(str("sample"),
                                                      (str("inet6") | str("inet") | str("mpls"))
                                                ),
                                                str("no-decrement-ttl"),
                                                a(str("forwarding-class"), arg),
                                                a(str("interface-group"), arg),
                                                c(
                                                  b(str("routing-instance"),
                                                      sc(
                                                          arg
                                                      )
                                                  ).as(:oneline)
                                                )
                                            )
                                        )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("encapsulate"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline),
                              b(str("reject"),
                                  sc(
                                      c(
                                        str("network-unreachable"),
                                        str("host-unreachable"),
                                        str("protocol-unreachable"),
                                        str("port-unreachable"),
                                        str("fragmentation-needed"),
                                        str("source-route-failed"),
                                        str("network-unknown"),
                                        str("host-unknown"),
                                        str("source-host-isolated"),
                                        str("network-prohibited"),
                                        str("host-prohibited"),
                                        str("bad-network-tos"),
                                        str("bad-host-tos"),
                                        str("administratively-prohibited"),
                                        str("precedence-violation"),
                                        str("precedence-cutoff"),
                                        str("tcp-reset")
                                      )
                                  )
                              ).as(:oneline),
                              a(str("load-balance"), arg)
                            ),
                            b(str("dscp"),
                              (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                            ),
                            b(str("dont-fragment"),
                              (str("clear") | str("set"))
                            ),
                            a(str("prefix-action"), arg)
                        )
                    ),
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet_fuf) do
      b(arg.as(:arg),
        c(
            str("interface-specific"),
            b(str("match-order"),
                  (str("protocol") | str("source-address") | str("destination-address") | str("source-port") | str("destination-port") | str("dscp"))
            ),
            b(a(str("term"), arg),
                c(
                    str("only-at-create"),
                    b(str("from"),
                        c(
                            b(str("source-address"),
                              firewall_addr_simple_object
                            ),
                            b(str("destination-address"),
                              firewall_addr_simple_object
                            ),
                            c(
                              b(str("source-port"),
                                match_simple_port_value
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                match_simple_port_value
                              )
                            ),
                            c(
                              b(str("protocol"),
                                match_simple_protocol_value
                              )
                            ),
                            c(
                              b(str("dscp"),
                                match_simple_dscp_value
                              )
                            ),
                            a(str("match-terms"), arg)
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg)
                            ),
                            a(str("count"), arg),
                            str("service-accounting"),
                            str("log"),
                            str("port-mirror"),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("forwarding-class"), arg),
                            a(str("action-terms"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              b(str("routing-instance"),
                                  sc(
                                      arg,
                                      a(str("topology"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:firewall_addr_simple_object) do
        c(
              ipv4prefix
        )
    end

    rule(:inet_service_filter) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            b(str("source-address"),
                              firewall_addr_object
                            ),
                            b(str("destination-address"),
                              firewall_addr_object
                            ),
                            b(str("address"),
                              firewall_addr_object
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              b(str("protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("ip-options"),
                                    (str("any"))
                              ),
                              b(str("ip-options-except"),
                                    (str("any"))
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              a(str("esp-spi"), arg),
                              a(str("esp-spi-except"), arg)
                            ),
                            str("is-fragment"),
                            str("first-fragment"),
                            c(
                              a(str("fragment-offset"), arg),
                              a(str("fragment-offset-except"), arg)
                            ),
                            a(str("fragment-flags"), arg),
                            a(str("tcp-flags"), arg),
                            c(
                              a(str("ah-spi"), arg),
                              a(str("ah-spi-except"), arg)
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            c(
                              b(str("redirect-reason"),
                                    (str("aoc") | str("aolb") | str("dpi"))
                              ),
                              b(str("redirect-reason-except"),
                                    (str("aoc") | str("aolb") | str("dpi"))
                              )
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            a(str("count"), arg),
                            str("log"),
                            str("pkt-trace"),
                            str("sample"),
                            str("port-mirror"),
                            c(
                              str("service"),
                              str("skip"),
                              str("accept")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet_simple_filter) do
      b(arg.as(:arg),
        c(
            str("interface-specific"),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("source-address"),
                              firewall_addr_simple_object
                            ),
                            b(str("destination-address"),
                              firewall_addr_simple_object
                            ),
                            c(
                              b(str("protocol"),
                                match_simple_protocol_value
                              )
                            ),
                            c(
                              b(str("source-port"),
                                match_simple_port_value
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                match_simple_port_value
                              )
                            ),
                            c(
                              a(str("forwarding-class"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("two-rate"), arg)
                                      )
                                  )
                              )
                            ),
                            b(str("loss-priority"),
                              (str("low") | str("medium-high") | str("medium-low") | str("high"))
                            ),
                            a(str("forwarding-class"), arg),
                            str("discard"),
                            str("accept")
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet_template) do
      b(arg.as(:arg),
        c(
            b(str("attributes"),
                c(
                    str("destination-address"),
                    str("destination-port"),
                    str("destination-port-range-optimize"),
                    str("destination-prefix-list"),
                    str("dscp"),
                    str("flexible-match-mask"),
                    str("flexible-match-range"),
                    str("fragment-flags"),
                    str("icmp-code"),
                    str("icmp-type"),
                    str("interface"),
                    str("ip-options"),
                    str("is-fragment"),
                    str("packet-length"),
                    str("precedence"),
                    str("protocol"),
                    str("rat-type"),
                    str("redirect-reason"),
                    str("source-address"),
                    str("source-port"),
                    str("source-port-range-optimize"),
                    str("source-prefix-list"),
                    str("tcp-established"),
                    str("tcp-flags"),
                    str("tcp-initial"),
                    str("ttl"),
                    str("egress-to-ingress")
                )
            )
        )
      )
    end

    rule(:interface_map_type) do
        c(
            a(str("file-specification"), arg),
            b(str("collector"),
              interface_device
            ),
              input_intf_to_cpic_map_type
        )
    end

    rule(:input_intf_to_cpic_map_type) do
      b(arg.as(:arg),
        c(
            a(str("file-specification"), arg),
            b(str("collector"),
              interface_device
            )
        )
      )
    end

    rule(:interface_set_type) do
      b(arg.as(:arg),
        c(
            arg
        )
      )
    end

    rule(:interface_type) do
      b((str("all") | arg).as(:arg),
        c(
            str("queue-statistics"),
            str("no-queue-statistics"),
            str("traffic-statistics"),
            str("no-traffic-statistics"),
            a(str("resource-profile"), arg)
        )
      )
    end

    rule(:interfaces_type) do
      b((arg | arg).as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("external-model-name"), arg),
            a(str("metadata"), arg),
              (str("disable")),
            str("promiscuous-mode"),
            a(str("port-mirror-instance"), arg),
            str("multicast-statistics"),
            str("oam-on-svlan"),
            b(str("fabric-options"),
                c(
                    a(str("member-interfaces"), arg),
                    b(str("remote-chassis"),
                        c(
                            b(str("destination"),
                              ipv4addr
                            )
                        )
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    a(str("flag"), enum(str("ipc") | str("event") | str("media") | str("all"))).as(:oneline)
                )
            ),
            str("passive-monitor-mode"),
            c(
              b(str("keepalives"),
                keepalives_type
              ).as(:oneline),
              str("no-keepalives")
            ),
            str("traps"),
            str("no-traps"),
            str("interface-mib"),
            str("no-interface-mib"),
            a(str("accounting-profile"), arg),
            b(str("anchor-point"),
                c(
                      interface_device
                )
            ),
            str("bypass-queueing-chip"),
            str("no-bypass-queueing-chip"),
            c(
              str("per-unit-scheduler"),
              str("no-per-unit-scheduler"),
              str("shared-scheduler"),
              b(str("hierarchical-scheduler"),
                  sc(
                      a(str("maximum-hierarchy-levels"), arg),
                      a(str("maximum-l2-nodes"), arg),
                      a(str("maximum-l3-nodes"), arg),
                      str("implicit-hierarchy")
                  )
              ).as(:oneline)
            ),
            a(str("l2tp-maximum-session"), arg),
            a(str("schedulers"), arg),
            str("interface-transmit-statistics"),
            str("cascade-port"),
            str("dce"),
            c(
              str("vlan-tagging"),
              str("stacked-vlan-tagging"),
              str("flexible-vlan-tagging"),
              str("vlan-vci-tagging")
            ),
            str("hybrid-access"),
            a(str("native-vlan-id"), arg),
            str("no-native-vlan-insert"),
            str("vlan-offload"),
            b(str("input-native-vlan-push"),
              (str("disable") | str("enable"))
            ),
            str("no-pseudowire-down-on-core-isolation"),
            b(str("speed"),
              (str("auto") | str("auto-10m-100m") | str("10m") | str("100m") | str("1g") | str("2.5g") | str("5g") | str("10g") | str("40g") | str("oc3") | str("oc12") | str("oc48"))
            ),
            b(str("forwarding-class-accounting"),
                c(
                    b(str("direction"),
                      (str("ingress") | str("egress") | str("both"))
                    ),
                    b(str("enhanced"),
                        c(
                            b(str("traffic-type"),
                              (str("unicast-statistics") | str("multicast-statistics"))
                            ),
                            b(str("family"),
                              (str("inet6") | str("inet") | str("both"))
                            ),
                            b(str("direction"),
                              (str("ingress") | str("egress") | str("both"))
                            ),
                            a(str("overhead-bytes"), arg)
                        )
                    )
                )
            ),
            b(str("auto-configure"),
              auto_configure_vlan_type
            ),
            a(str("mtu"), arg),
            b(str("hold-time"),
                sc(
                    a(str("up"), arg),
                    a(str("down"), arg)
                )
            ).as(:oneline),
            b(str("damping"),
                c(
                    a(str("half-life"), arg),
                    a(str("max-suppress"), arg),
                    a(str("reuse"), arg),
                    a(str("suppress"), arg),
                    str("enable")
                )
            ),
            b(str("link-degrade-monitor"),
                c(
                    b(str("actions"),
                        c(
                            c(
                              str("media-based")
                            )
                        )
                    ),
                    b(str("recovery"),
                        c(
                            a(str("timer"), arg),
                            c(
                              str("auto"),
                              str("manual")
                            )
                        )
                    ),
                    b(str("thresholds"),
                        c(
                            a(str("set"), arg),
                            a(str("clear"), arg),
                            a(str("warning-set"), arg),
                            a(str("warning-clear"), arg),
                            a(str("interval"), arg)
                        )
                    )
                )
            ),
            b(str("satop-options"),
                c(
                    a(str("idle-pattern"), arg),
                    a(str("payload-size"), arg),
                    b(str("excessive-packet-loss-rate"),
                        c(
                            a(str("threshold"), arg),
                            a(str("sample-period"), arg)
                        )
                    ),
                    c(
                      a(str("jitter-buffer-packets"), arg),
                      a(str("jitter-buffer-latency"), arg),
                      str("jitter-buffer-auto-adjust")
                    ),
                    a(str("bit-rate"), arg)
                )
            ),
            b(str("cesopsn-options"),
                c(
                    a(str("idle-pattern"), arg),
                    a(str("packetization-latency"), arg),
                    a(str("payload-size"), arg),
                    b(str("excessive-packet-loss-rate"),
                        c(
                            a(str("threshold"), arg),
                            a(str("sample-period"), arg)
                        )
                    ),
                    c(
                      a(str("jitter-buffer-packets"), arg),
                      a(str("jitter-buffer-latency"), arg),
                      str("jitter-buffer-auto-adjust")
                    ),
                    a(str("bit-rate"), arg)
                )
            ),
            b(str("ima-group-options"),
                c(
                    b(str("frame-length"),
                      (str("32") | str("64") | str("128") | str("256"))
                    ),
                    b(str("symmetry"),
                      (str("symmetrical-config-and-operation") | str("symmetrical-config-asymmetrical-operation"))
                    ),
                    b(str("transmit-clock"),
                      (str("common") | str("independent"))
                    ),
                    b(str("version"),
                      (str("1.0") | str("1.1"))
                    ),
                    b(str("minimum-links"),
                        c(
                            c(
                                arg
                            )
                        )
                    ),
                    b(str("frame-synchronization"),
                        c(
                            a(str("alpha"), arg),
                            a(str("beta"), arg),
                            a(str("gamma"), arg)
                        )
                    ),
                    b(str("test-procedure"),
                        c(
                            a(str("period"), arg),
                            b(str("interface"),
                              interface_device
                            ),
                            a(str("pattern"), arg)
                        )
                    ),
                    a(str("differential-delay"), arg)
                )
            ),
            b(str("ima-link-options"),
                c(
                    a(str("group-id"), arg)
                )
            ),
            b(str("multi-chassis-protection"),
              multi_chassis_protection_group
            ),
            b(str("clocking"),
                sc(
                    c(
                      str("internal"),
                      str("external")
                    )
                )
            ).as(:oneline),
            b(str("link-mode"),
              (str("automatic") | str("half-duplex") | str("full-duplex"))
            ),
            b(str("media-type"),
              (str("copper") | str("fiber"))
            ),
            b(str("encapsulation"),
              (str("ethernet-ccc") | str("fddi") | str("token-ring") | str("ppp") | str("ppp-ccc") | str("ppp-tcc") | str("ether-vpls-ppp") | str("frame-relay") | str("frame-relay-ccc") | str("frame-relay-tcc") | str("extended-frame-relay-ccc") | str("extended-frame-relay-tcc") | str("flexible-frame-relay") | str("frame-relay-port-ccc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("extended-frame-relay-ether-type-tcc") | str("cisco-hdlc") | str("cisco-hdlc-ccc") | str("cisco-hdlc-tcc") | str("vlan-ccc") | str("extended-vlan-ccc") | str("ethernet-tcc") | str("flexible-ethernet-services") | str("smds-dxi") | str("atm-pvc") | str("atm-ccc-cell-relay") | str("ethernet-over-atm") | str("ethernet-vpls") | str("extended-vlan-tcc") | str("multilink-frame-relay-uni-nni") | str("satop") | str("cesopsn") | str("ima") | str("ethernet-bridge") | str("ethernet") | str("vlan-vpls") | str("vlan-vci-ccc") | str("extended-vlan-vpls") | str("extended-vlan-bridge") | str("multilink-ppp") | str("generic-services"))
            ),
            b(str("esi"),
                c(
                    b(str("auto-derive"),
                        c(
                            c(
                              str("lacp")
                            )
                        )
                    ),
                      esi,
                    c(
                      str("single-active"),
                      str("all-active")
                    ),
                    b(str("df-election-type"),
                        c(
                            c(
                              b(str("preference"),
                                  c(
                                      a(str("value"), arg)
                                  )
                              )
                            ),
                            c(
                              str("mod")
                            )
                        )
                    ),
                    b(str("source-bmac"),
                      mac_unicast
                    )
                )
            ),
            b(str("framing"),
                c(
                    c(
                      str("lan-phy"),
                      str("wan-phy"),
                      str("sonet"),
                      str("sdh")
                    ),
                    str("precise-bandwidth")
                )
            ),
            str("unidirectional"),
            b(str("lmi"),
                c(
                    a(str("n391dte"), arg),
                    a(str("n392dce"), arg),
                    a(str("n392dte"), arg),
                    a(str("n393dce"), arg),
                    a(str("n393dte"), arg),
                    a(str("t391dte"), arg),
                    a(str("t392dce"), arg),
                    b(str("lmi-type"),
                      (str("ansi") | str("itu") | str("c-lmi"))
                    )
                )
            ),
            b(str("mlfr-uni-nni-bundle-options"),
                c(
                    b(str("cisco-interoperability"),
                        c(
                            str("send-lip-remove-link-for-link-reject")
                        )
                    ),
                    a(str("mrru"), arg),
                    a(str("yellow-differential-delay"), arg),
                    a(str("red-differential-delay"), arg),
                    b(str("action-red-differential-delay"),
                      (str("remove-link") | str("disable-tx"))
                    ),
                    a(str("fragment-threshold"), arg),
                    a(str("drop-timeout"), arg),
                    b(str("link-layer-overhead"),
                      unsigned_float
                    ),
                    b(str("lmi-type"),
                      (str("ansi") | str("itu") | str("c-lmi"))
                    ),
                    a(str("minimum-links"), arg),
                    a(str("hello-timer"), arg),
                    a(str("acknowledge-timer"), arg),
                    a(str("acknowledge-retries"), arg),
                    a(str("n391"), arg),
                    a(str("n392"), arg),
                    a(str("n393"), arg),
                    a(str("t391"), arg),
                    a(str("t392"), arg)
                )
            ),
            b(str("mac"),
              mac_unicast
            ),
            b(str("receive-bucket"),
              dcd_rx_bucket_config
            ),
            b(str("transmit-bucket"),
              dcd_tx_bucket_config
            ),
            str("shared-interface"),
            b(str("sonet-options"),
              sonet_options_type
            ),
            b(str("logical-tunnel-options"),
                c(
                    b(str("link-protection"),
                        c(
                            str("revertive"),
                            str("non-revertive")
                        )
                    ),
                    str("per-unit-mac-disable"),
                    b(str("load-balance"),
                      aggregate_load_balance
                    )
                )
            ),
            b(str("aggregated-sonet-options"),
                c(
                    a(str("minimum-links"), arg),
                    b(str("link-speed"),
                      (str("oc3") | str("oc12") | str("oc48") | str("oc192") | str("oc768") | str("mixed"))
                    ),
                    a(str("minimum-bandwidth"), arg)
                )
            ),
            b(str("atm-options"),
                c(
                    b(str("pic-type"),
                      (str("atm-ce") | str("atm2") | str("atm1"))
                    ),
                    a(str("cell-bundle-size"), arg),
                    a(str("cell-bundle-timeout"), arg),
                    str("plp-to-clp"),
                    str("use-null-cw"),
                    b(str("promiscuous-mode"),
                        c(
                            a(str("vpi"), arg).as(:oneline)
                        )
                    ),
                    b(a(str("vpi"), arg),
                        c(
                            a(str("maximum-vcs"), arg),
                            b(str("shaping"),
                              dcd_shaping_config
                            ),
                            b(str("oam-period"),
                                sc(
                                    ca(
                                      str("disable").as(:oneline)
                                    )
                                )
                            ).as(:oneline),
                            b(str("oam-liveness"),
                                c(
                                    a(str("up-count"), arg),
                                    a(str("down-count"), arg)
                                )
                            )
                        )
                    ),
                    str("ilmi"),
                    b(a(str("linear-red-profiles"), arg),
                        sc(
                            a(str("queue-depth"), arg),
                            a(str("high-plp-threshold"), arg),
                            a(str("low-plp-threshold"), arg),
                            a(str("high-plp-max-threshold"), arg),
                            a(str("low-plp-max-threshold"), arg)
                        )
                    ).as(:oneline),
                    b(a(str("scheduler-maps"), arg),
                        c(
                            b(str("vc-cos-mode"),
                              (str("strict") | str("alternate"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    b(str("priority"),
                                      (str("low") | str("high"))
                                    ),
                                    b(str("transmit-weight"),
                                        sc(
                                            c(
                                              a(str("percent"), arg),
                                              a(str("cells"), arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    c(
                                      b(str("epd-threshold"),
                                        epd_threshold_config
                                      ).as(:oneline),
                                      a(str("linear-red-profile"), arg)
                                    )
                                )
                            )
                        )
                    ),
                    b(str("mpls"),
                      mpls_ifd_options
                    ),
                    str("payload-scrambler"),
                    str("no-payload-scrambler")
                )
            ),
            b(str("multiservice-options"),
                c(
                    str("syslog"),
                    str("no-syslog"),
                    str("core-dump"),
                    str("no-core-dump"),
                    str("dump-on-flow-control"),
                    str("no-dump-on-flow-control"),
                    str("reset-on-flow-control"),
                    str("no-reset-on-flow-control"),
                    b(str("flow-control-options"),
                        c(
                            str("dump-on-flow-control"),
                            str("reset-on-flow-control"),
                            str("down-on-flow-control"),
                            str("up-on-flow-control")
                        )
                    )
                )
            ),
            b(str("ggsn-options"),
                c(
                    str("syslog"),
                    str("no-syslog"),
                    str("core-dump"),
                    str("no-core-dump")
                )
            ),
            b(str("ppp-options"),
              ppp_options_type
            ),
            b(str("redundancy-options"),
                c(
                    b(str("primary"),
                      interface_device
                    ),
                    b(str("secondary"),
                      interface_device
                    ),
                    b(str("redundancy-peer"),
                        c(
                            b(str("ipaddress"),
                              ipv4addr
                            )
                        )
                    ),
                    b(str("redundancy-local"),
                        c(
                            b(str("data-address"),
                              ipv4addr
                            )
                        )
                    ),
                    a(str("routing-instance"), arg),
                    a(str("replication-threshold"), arg),
                    b(str("replication-options"),
                        c(
                            a(str("mtu"), arg)
                        )
                    ),
                    b(str("replicate-services"),
                        c(
                            str("pgcp")
                        )
                    )
                )
            ),
            b(str("load-balancing-options"),
                c(
                    a(str("member-interface"), arg),
                    b(str("member-failure-options"),
                        c(
                            c(
                              b(str("redistribute-all-traffic"),
                                  c(
                                      str("enable-rejoin")
                                  )
                              ),
                              b(str("drop-member-traffic"),
                                  c(
                                      a(str("rejoin-timeout"), arg),
                                      str("enable-rejoin")
                                  )
                              )
                            )
                        )
                    ),
                    b(str("high-availability-options"),
                        c(
                            c(
                              b(str("many-to-one"),
                                  c(
                                      b(str("preferred-backup"),
                                        interface_device
                                      )
                                  )
                              ),
                              b(str("one-to-one"),
                                  c(
                                      b(str("preferred-backup"),
                                        interface_device
                                      )
                                  )
                              )
                            )
                        )
                    )
                )
            ),
            b(str("aggregated-inline-services-options"),
                c(
                    b(str("primary-interface"),
                      interface_device
                    ),
                    b(str("secondary-interface"),
                      interface_device
                    )
                )
            ),
            b(str("anchoring-options"),
                c(
                    a(str("apfe-group-set"), arg),
                    a(str("primary-list"), arg),
                    b(str("secondary"),
                        c(
                            arg
                        )
                    ),
                    c(
                      str("warm-standby")
                    )
                )
            ),
            b(str("lsq-failure-options"),
                c(
                    a(str("trigger-link-failure"), arg),
                    str("no-termination-request"),
                    str("no-no-termination-request")
                )
            ),
            b(str("redundancy-group"),
                c(
                    b(a(str("member-interface"), arg),
                        c(
                            c(
                              str("active"),
                              str("backup")
                            )
                        )
                    ),
                    a(str("maximum-links"), arg)
                )
            ),
            b(str("services-options"),
                c(
                    b(str("syslog"),
                      log_object
                    ),
                    b(str("jflow-log"),
                        c(
                            a(str("message-rate-limit"), arg)
                        )
                    ),
                    b(str("deterministic-nat-configuration-log-interval"),
                        c(
                            a(str("interval"), arg)
                        )
                    ),
                    a(str("open-timeout"), arg),
                    a(str("close-timeout"), arg),
                    a(str("inactivity-timeout"), arg),
                    a(str("inactivity-tcp-timeout"), arg),
                    a(str("inactivity-asymm-tcp-timeout"), arg),
                    a(str("inactivity-non-tcp-timeout"), arg),
                    a(str("session-timeout"), arg),
                    str("disable-global-timeout-override"),
                    a(str("tcp-tickles"), arg),
                    b(str("trio-flow-offload"),
                        c(
                            a(str("minimum-bytes"), arg)
                        )
                    ),
                    a(str("fragment-limit"), arg),
                    a(str("reassembly-timeout"), arg),
                    str("cgn-pic"),
                    a(str("pba-interim-logging-interval"), arg),
                    b(str("session-limit"),
                        c(
                            a(str("maximum"), arg),
                            a(str("rate"), arg),
                            a(str("cpu-load-threshold"), arg)
                        )
                    ),
                    str("enable-subscriber-analysis"),
                    str("disable-usp-tracing"),
                    str("disable-drop-flows"),
                    b(str("ignore-errors"),
                        sc(
                            str("tcp"),
                            str("alg")
                        )
                    ).as(:oneline),
                    b(str("capture"),
                        c(
                            a(str("capture-size"), arg),
                            a(str("pkt-size"), arg),
                            a(str("logs-per-packet"), arg),
                            a(str("max-log-line-size"), arg),
                            b(str("filter"),
                                c(
                                    b(str("source-ip"),
                                        sc(
                                            b(str("wildcard"),
                                              ipaddr
                                            ),
                                              ipaddr
                                        )
                                    ).as(:oneline),
                                    b(str("dest-ip"),
                                        sc(
                                            b(str("wildcard"),
                                              ipaddr
                                            ),
                                              ipaddr
                                        )
                                    ).as(:oneline),
                                    b(str("sw-sip"),
                                        sc(
                                            b(str("wildcard"),
                                              ipv6addr
                                            ),
                                              ipv6addr
                                        )
                                    ).as(:oneline),
                                    b(str("sw-dip"),
                                        sc(
                                            b(str("wildcard"),
                                              ipaddr
                                            ),
                                              ipaddr
                                        )
                                    ).as(:oneline),
                                    b(str("sport-range"),
                                        sc(
                                            a(str("low"), arg),
                                            a(str("high"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("dport-range"),
                                        sc(
                                            a(str("low"), arg),
                                            a(str("high"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("proto"),
                                      (str("icmp") | str("tcp") | str("udp"))
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("t3-options"),
                c(
                    b(str("loopback"),
                      (str("local") | str("remote") | str("payload"))
                    ),
                    str("long-buildout"),
                    str("no-long-buildout"),
                    str("loop-timing"),
                    str("no-loop-timing"),
                    str("unframed"),
                    str("no-unframed"),
                    b(str("compatibility-mode"),
                        sc(
                            c(
                              b(str("larscom"),
                                  sc(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("verilink"),
                                  sc(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("adtran"),
                                  sc(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("kentrox"),
                                  sc(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("digital-link"),
                                  sc(
                                      b(str("subrate"),
                                        (str("301Kb") | str("601Kb") | str("902Kb") | str("1.2Mb") | str("1.5Mb") | str("1.8Mb") | str("2.1Mb") | str("2.4Mb") | str("2.7Mb") | str("3.0Mb") | str("3.3Mb") | str("3.6Mb") | str("3.9Mb") | str("4.2Mb") | str("4.5Mb") | str("4.8Mb") | str("5.1Mb") | str("5.4Mb") | str("5.7Mb") | str("6.0Mb") | str("6.3Mb") | str("6.6Mb") | str("6.9Mb") | str("7.2Mb") | str("7.5Mb") | str("7.8Mb") | str("8.1Mb") | str("8.4Mb") | str("8.7Mb") | str("9.0Mb") | str("9.3Mb") | str("9.6Mb") | str("9.9Mb") | str("10.2Mb") | str("10.5Mb") | str("10.8Mb") | str("11.1Mb") | str("11.4Mb") | str("11.7Mb") | str("12.0Mb") | str("12.3Mb") | str("12.6Mb") | str("12.9Mb") | str("13.2Mb") | str("13.5Mb") | str("13.8Mb") | str("14.1Mb") | str("14.4Mb") | str("14.7Mb") | str("15.0Mb") | str("15.3Mb") | str("15.6Mb") | str("15.9Mb") | str("16.2Mb") | str("16.5Mb") | str("16.8Mb") | str("17.1Mb") | str("17.4Mb") | str("17.7Mb") | str("18.0Mb") | str("18.3Mb") | str("18.6Mb") | str("18.9Mb") | str("19.2Mb") | str("19.5Mb") | str("19.8Mb") | str("20.1Mb") | str("20.5Mb") | str("20.8Mb") | str("21.1Mb") | str("21.4Mb") | str("21.7Mb") | str("22.0Mb") | str("22.3Mb") | str("22.6Mb") | str("22.9Mb") | str("23.2Mb") | str("23.5Mb") | str("23.8Mb") | str("24.1Mb") | str("24.4Mb") | str("24.7Mb") | str("25.0Mb") | str("25.3Mb") | str("25.6Mb") | str("25.9Mb") | str("26.2Mb") | str("26.5Mb") | str("26.8Mb") | str("27.1Mb") | str("27.4Mb") | str("27.7Mb") | str("28.0Mb") | str("28.3Mb") | str("28.6Mb") | str("28.9Mb") | str("29.2Mb") | str("29.5Mb") | str("29.8Mb") | str("30.1Mb") | str("30.4Mb") | str("30.7Mb") | str("31.0Mb") | str("31.3Mb") | str("31.6Mb") | str("31.9Mb") | str("32.2Mb") | str("32.5Mb") | str("32.8Mb") | str("33.1Mb") | str("33.4Mb") | str("33.7Mb") | str("34.0Mb") | str("34.3Mb") | str("34.6Mb") | str("34.9Mb") | str("35.2Mb") | str("35.5Mb") | str("35.8Mb") | str("36.1Mb") | str("36.4Mb") | str("36.7Mb") | str("37.0Mb") | str("37.3Mb") | str("37.6Mb") | str("37.9Mb") | str("38.2Mb") | str("38.5Mb") | str("38.8Mb") | str("39.1Mb") | str("39.4Mb") | str("39.7Mb") | str("40.0Mb") | str("40.3Mb") | str("40.6Mb") | str("40.9Mb") | str("41.2Mb") | str("41.5Mb") | str("41.8Mb") | str("42.1Mb") | str("42.4Mb") | str("42.7Mb") | str("43.0Mb") | str("43.3Mb") | str("43.6Mb") | str("43.9Mb") | str("44.2Mb"))
                                      )
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    str("payload-scrambler"),
                    str("no-payload-scrambler"),
                    str("cbit-parity"),
                    str("no-cbit-parity"),
                    b(str("fcs"),
                      (str("32") | str("16"))
                    ),
                    b(str("idle-cycle-flag"),
                      (str("flags") | str("ones"))
                    ),
                    b(str("start-end-flag"),
                      (str("shared") | str("filler"))
                    ),
                    str("feac-loop-respond"),
                    str("no-feac-loop-respond"),
                    b(str("bert-algorithm"),
                      (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                    ),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg),
                    a(str("buildout"), arg),
                    b(str("atm-encapsulation"),
                      (str("plcp") | str("direct"))
                    )
                )
            ),
            b(str("e3-options"),
                c(
                    b(str("loopback"),
                      (str("local") | str("remote"))
                    ),
                    str("unframed"),
                    str("no-unframed"),
                    b(str("compatibility-mode"),
                        sc(
                            c(
                              str("larscom"),
                              b(str("digital-link"),
                                  sc(
                                      b(str("subrate"),
                                        (str("358Kb") | str("716Kb") | str("1.1Mb") | str("1.4Mb") | str("1.8Mb") | str("2.1Mb") | str("2.5Mb") | str("2.9Mb") | str("3.2Mb") | str("3.6Mb") | str("3.9Mb") | str("4.3Mb") | str("4.7Mb") | str("5.0Mb") | str("5.4Mb") | str("5.7Mb") | str("6.1Mb") | str("6.4Mb") | str("6.8Mb") | str("7.2Mb") | str("7.5Mb") | str("7.9Mb") | str("8.2Mb") | str("8.6Mb") | str("9.0Mb") | str("9.3Mb") | str("9.7Mb") | str("10.0Mb") | str("10.4Mb") | str("10.7Mb") | str("11.1Mb") | str("11.5Mb") | str("11.8Mb") | str("12.2Mb") | str("12.5Mb") | str("12.9Mb") | str("13.2Mb") | str("13.6Mb") | str("14.0Mb") | str("14.3Mb") | str("14.7Mb") | str("15.0Mb") | str("15.4Mb") | str("15.8Mb") | str("16.1Mb") | str("16.5Mb") | str("16.8Mb") | str("17.2Mb") | str("17.5Mb") | str("17.9Mb") | str("18.3Mb") | str("18.6Mb") | str("19.0Mb") | str("19.3Mb") | str("19.7Mb") | str("20.0Mb") | str("20.4Mb") | str("20.8Mb") | str("21.1Mb") | str("21.5Mb") | str("21.8Mb") | str("22.2Mb") | str("22.6Mb") | str("22.9Mb") | str("23.3Mb") | str("23.6Mb") | str("24.0Mb") | str("24.3Mb") | str("24.7Mb") | str("25.1Mb") | str("25.4Mb") | str("25.8Mb") | str("26.1Mb") | str("26.5Mb") | str("26.9Mb") | str("27.2Mb") | str("27.6Mb") | str("27.9Mb") | str("28.3Mb") | str("28.6Mb") | str("29.0Mb") | str("29.4Mb") | str("29.7Mb") | str("30.1Mb") | str("30.4Mb") | str("30.8Mb") | str("31.1Mb") | str("31.5Mb") | str("31.9Mb") | str("32.2Mb") | str("32.6Mb") | str("32.9Mb") | str("33.3Mb") | str("33.7Mb") | str("34.0Mb"))
                                      )
                                  )
                              ).as(:oneline),
                              b(str("kentrox"),
                                  sc(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    str("payload-scrambler"),
                    str("no-payload-scrambler"),
                    b(str("fcs"),
                      (str("32") | str("16"))
                    ),
                    b(str("idle-cycle-flag"),
                      (str("flags") | str("ones"))
                    ),
                    str("invert-data"),
                    b(str("start-end-flag"),
                      (str("shared") | str("filler"))
                    ),
                    b(str("bert-algorithm"),
                      (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                    ),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg),
                    a(str("buildout"), arg),
                    b(str("atm-encapsulation"),
                      (str("plcp") | str("direct"))
                    ),
                    b(str("framing"),
                      (str("g.751") | str("g.832"))
                    )
                )
            ),
            b(str("e1-options"),
                c(
                    a(str("timeslots"), arg),
                    b(str("loopback"),
                      (str("local") | str("remote"))
                    ),
                    b(str("framing"),
                      (str("g704") | str("unframed") | str("g704-no-crc4"))
                    ),
                    b(str("fcs"),
                      (str("32") | str("16"))
                    ),
                    str("invert-data"),
                    b(str("idle-cycle-flag"),
                      (str("flags") | str("ones"))
                    ),
                    b(str("start-end-flag"),
                      (str("shared") | str("filler"))
                    ),
                    b(str("bert-algorithm"),
                      (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                    ),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg)
                )
            ),
            b(str("t1-options"),
                c(
                    a(str("timeslots"), arg),
                    a(str("voice-timeslots"), arg),
                    b(str("disable-remote-alarm-detection"),
                      (str("yellow"))
                    ),
                    b(str("loopback"),
                      (str("local") | str("remote") | str("payload"))
                    ),
                    b(str("buildout"),
                      (str("0-132") | str("133-265") | str("266-398") | str("399-531") | str("532-655") | str("long-0db") | str("long-7.5db") | str("long-15db") | str("long-22.5db"))
                    ),
                    b(str("byte-encoding"),
                      (str("nx64") | str("nx56"))
                    ),
                    b(str("line-encoding"),
                      (str("ami") | str("b8zs"))
                    ),
                    str("invert-data"),
                    b(str("framing"),
                      (str("sf") | str("esf"))
                    ),
                    b(str("fcs"),
                      (str("32") | str("16"))
                    ),
                    b(str("idle-cycle-flag"),
                      (str("flags") | str("ones"))
                    ),
                    b(str("start-end-flag"),
                      (str("shared") | str("filler"))
                    ),
                    b(str("bert-algorithm"),
                      (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                    ),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg),
                    str("remote-loopback-respond"),
                    b(str("crc-major-alarm-threshold"),
                      (str("1e-3") | str("5e-4") | str("1e-4") | str("5e-5") | str("1e-5"))
                    ),
                    b(str("crc-minor-alarm-threshold"),
                      (str("1e-3") | str("5e-4") | str("1e-4") | str("5e-5") | str("1e-5") | str("5e-6") | str("1e-6"))
                    ),
                    b(str("alarm-compliance"),
                      (str("accunet-t1-5-service"))
                    )
                )
            ),
            b(str("ds0-options"),
                c(
                    b(str("loopback"),
                      (str("payload"))
                    ),
                    b(str("byte-encoding"),
                      (str("nx64") | str("nx56"))
                    ),
                    str("invert-data"),
                    b(str("fcs"),
                      (str("32") | str("16"))
                    ),
                    b(str("idle-cycle-flag"),
                      (str("flags") | str("ones"))
                    ),
                    b(str("start-end-flag"),
                      (str("shared") | str("filler"))
                    ),
                    b(str("bert-algorithm"),
                      (str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4") | str("repeating-1-in-16"))
                    ),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg)
                )
            ),
            b(str("serial-options"),
                c(
                    b(str("line-protocol"),
                      (str("eia530") | str("v.35") | str("x.21"))
                    ),
                    c(
                      b(str("dte-options"),
                          c(
                              str("ignore-all"),
                              b(str("dtr"),
                                  sc(
                                      c(
                                        str("assert"),
                                        str("de-assert"),
                                        str("normal"),
                                        b(str("auto-synchronize"),
                                            c(
                                                a(str("duration"), arg),
                                                a(str("interval"), arg)
                                            )
                                        )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("control-signal"),
                                (str("assert") | str("de-assert") | str("normal"))
                              ),
                              b(str("rts"),
                                (str("assert") | str("de-assert") | str("normal"))
                              ),
                              b(str("dcd"),
                                (str("require") | str("ignore") | str("normal"))
                              ),
                              b(str("dsr"),
                                (str("require") | str("ignore") | str("normal"))
                              ),
                              b(str("cts"),
                                (str("require") | str("ignore") | str("normal"))
                              ),
                              b(str("indication"),
                                (str("require") | str("ignore") | str("normal"))
                              ),
                              b(str("tm"),
                                (str("require") | str("ignore") | str("normal"))
                              )
                          )
                      ),
                      b(str("dce-options"),
                          c(
                              str("ignore-all"),
                              b(str("dtr"),
                                (str("require") | str("ignore") | str("normal"))
                              ),
                              b(str("rts"),
                                (str("require") | str("ignore") | str("normal"))
                              ),
                              b(str("dcd"),
                                (str("assert") | str("de-assert") | str("normal"))
                              ),
                              b(str("dsr"),
                                (str("assert") | str("de-assert") | str("normal"))
                              ),
                              b(str("cts"),
                                (str("assert") | str("de-assert") | str("normal"))
                              ),
                              b(str("tm"),
                                (str("require") | str("ignore") | str("normal"))
                              ),
                              str("dce-loopback-override")
                          )
                      )
                    ),
                    b(str("dtr-circuit"),
                      (str("balanced") | str("unbalanced"))
                    ),
                    b(str("dtr-polarity"),
                      (str("positive") | str("negative"))
                    ),
                    b(str("rts-polarity"),
                      (str("positive") | str("negative"))
                    ),
                    b(str("control-polarity"),
                      (str("positive") | str("negative"))
                    ),
                    b(str("dcd-polarity"),
                      (str("positive") | str("negative"))
                    ),
                    b(str("dsr-polarity"),
                      (str("positive") | str("negative"))
                    ),
                    b(str("cts-polarity"),
                      (str("positive") | str("negative"))
                    ),
                    b(str("indication-polarity"),
                      (str("positive") | str("negative"))
                    ),
                    b(str("tm-polarity"),
                      (str("positive") | str("negative"))
                    ),
                    b(str("clocking-mode"),
                      (str("dce") | str("internal") | str("loop"))
                    ),
                    b(str("transmit-clock"),
                      (str("invert"))
                    ),
                    b(str("clock-rate"),
                      (str("2.048mhz") | str("2.341mhz") | str("2.731mhz") | str("3.277mhz") | str("4.096mhz") | str("5.461mhz") | str("8.192mhz") | str("16.384mhz") | str("1.2khz") | str("2.4khz") | str("9.6khz") | str("19.2khz") | str("38.4khz") | str("56.0khz") | str("64.0khz") | str("72.0khz") | str("125.0khz") | str("148.0khz") | str("250.0khz") | str("500.0khz") | str("800.0khz") | str("1.0mhz") | str("1.3mhz") | str("2.0mhz") | str("4.0mhz") | str("8.0mhz"))
                    ),
                    b(str("loopback"),
                      (str("local") | str("remote") | str("dce-local") | str("dce-remote"))
                    ),
                    b(str("encoding"),
                      (str("nrz") | str("nrzi"))
                    ),
                    b(str("idle-cycle-flag"),
                      (str("flags") | str("ones"))
                    )
                )
            ),
            str("gratuitous-arp-reply"),
            str("no-gratuitous-arp-reply"),
            str("no-gratuitous-arp-request"),
            str("no-no-gratuitous-arp-request"),
            str("arp-l2-validate"),
            b(str("ether-options"),
                c(
                    str("loopback"),
                    str("no-loopback"),
                    str("source-filtering"),
                    str("no-source-filtering"),
                    b(str("ethernet-switch-profile"),
                        c(
                            a(str("tag-protocol-id"), arg),
                            b(str("ethernet-policer-profile"),
                                c(
                                    b(str("input-priority-map"),
                                      cos_policer_input_priority_map
                                    ),
                                    b(str("output-priority-map"),
                                      cos_policer_output_priority_map
                                    ),
                                    b(str("policer"),
                                      cos_policer
                                    )
                                )
                            ),
                            b(str("storm-control"),
                                c(
                                    arg
                                )
                            ),
                            b(str("recovery-timeout"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            str("mac-learn-enable"),
                            str("no-mac-learn-enable")
                        )
                    ),
                    str("asynchronous-notification"),
                    a(str("source-address-filter"), arg).as(:oneline),
                    str("auto-negotiation"),
                    str("no-auto-negotiation"),
                    str("flow-control"),
                    str("no-flow-control"),
                    b(str("configured-flow-control"),
                        c(
                            b(str("rx-buffers"),
                              (str("on") | str("off"))
                            ),
                            b(str("tx-buffers"),
                              (str("on") | str("off"))
                            )
                        )
                    ),
                    b(str("link-mode"),
                      (str("automatic") | str("half-duplex") | str("full-duplex"))
                    ),
                    b(str("mpls"),
                      mpls_ifd_options
                    ),
                    str("ignore-l3-incompletes"),
                    str("no-auto-mdix"),
                    b(str("speed"),
                        c(
                            c(
                              b(str("auto-negotiation"),
                                  sc(
                                      str("auto-negotiate-10-100")
                                  )
                              ).as(:oneline),
                              str("ethernet-10m"),
                              str("ethernet-100m"),
                              str("ethernet-1g"),
                              str("ethernet-10g")
                            )
                        )
                    ),
                    b(str("802.3ad"),
                        c(
                            b(str("lacp"),
                                c(
                                    str("force-up"),
                                    a(str("port-priority"), arg)
                                )
                            ),
                              interface_device,
                            c(
                              str("primary"),
                              str("backup")
                            ),
                            b(str("link-protection-sub-group"),
                                c(
                                      arg
                                )
                            ),
                            a(str("port-priority"), arg)
                        )
                    ),
                    str("ieee-802-3az-eee"),
                    b(str("mdi-mode"),
                      (str("auto") | str("force") | str("mdi") | str("mdix"))
                    ),
                    b(str("redundant-parent"),
                        c(
                              interface_device
                        )
                    ),
                    str("autostate-exclude")
                )
            ),
            b(str("fibrechannel-options"),
                c(
                    str("loopback"),
                    str("no-loopback"),
                    a(str("bb-sc-n"), arg),
                    b(str("speed"),
                      (str("auto-negotiation") | str("1g") | str("2g") | str("4g") | str("8g"))
                    )
                )
            ),
            b(str("gigether-options"),
                c(
                    str("loopback"),
                    str("no-loopback"),
                    str("loopback-remote"),
                    str("flow-control"),
                    str("no-flow-control"),
                    str("source-filtering"),
                    str("no-source-filtering"),
                    c(
                      str("no-auto-negotiation"),
                      b(str("auto-negotiation"),
                          sc(
                              b(str("remote-fault"),
                                (str("local-interface-offline") | str("local-interface-online"))
                              )
                          )
                      ).as(:oneline)
                    ),
                    b(str("mac-mode"),
                      (str("sgmii") | str("mac-mode-1000base-x"))
                    ),
                    str("asynchronous-notification"),
                    a(str("source-address-filter"), arg).as(:oneline),
                    str("pad-to-minimum-frame-size"),
                    b(str("redundant-parent"),
                        c(
                              interface_device
                        )
                    ),
                    b(str("802.3ad"),
                        c(
                            b(str("lacp"),
                                c(
                                    a(str("port-priority"), arg)
                                )
                            ),
                              interface_device,
                            a(str("link-index"), arg),
                            c(
                              str("primary"),
                              str("backup")
                            ),
                            a(str("distribution-list"), arg)
                        )
                    ),
                    b(str("ethernet-switch-profile"),
                        c(
                            a(str("tag-protocol-id"), arg),
                            b(str("ethernet-policer-profile"),
                                c(
                                    b(str("ieee802.1-priority-map"),
                                        c(
                                            a(str("premium"), arg)
                                        )
                                    ),
                                    b(str("input-priority-map"),
                                      cos_policer_input_priority_map
                                    ),
                                    b(str("output-priority-map"),
                                      cos_policer_output_priority_map
                                    ),
                                    b(str("policer"),
                                      cos_policer
                                    )
                                )
                            ),
                            b(str("accept-from"),
                                c(
                                    b(str("mac-address"),
                                      mac_list
                                    )
                                )
                            ),
                            str("reject-the-rest"),
                            str("no-reject-the-rest"),
                            str("mac-learn-enable")
                        )
                    ),
                    b(str("mpls"),
                      mpls_ifd_options
                    ),
                    str("ignore-l3-incompletes"),
                    str("no-auto-mdix"),
                    str("ieee-802-3az-eee"),
                    a(str("mru"), arg),
                    b(str("fec"),
                      (str("none") | str("fec91") | str("fec74") | str("fec108"))
                    ),
                    b(str("speed"),
                      (str("1g") | str("10g"))
                    )
                )
            ),
            b(str("optics-options"),
                c(
                    b(str("wavelength"),
                      (str("1568.77") | str("1568.36") | str("1568.31") | str("1568.26") | str("1568.21") | str("1568.16") | str("1568.11") | str("1568.05") | str("1568.00") | str("1567.95") | str("1567.90") | str("1567.85") | str("1567.80") | str("1567.75") | str("1567.70") | str("1567.64") | str("1567.59") | str("1567.54") | str("1567.49") | str("1567.44") | str("1567.39") | str("1567.34") | str("1567.29") | str("1567.23") | str("1567.18") | str("1567.13") | str("1567.08") | str("1567.03") | str("1566.98") | str("1566.93") | str("1566.88") | str("1566.83") | str("1566.77") | str("1566.72") | str("1566.67") | str("1566.62") | str("1566.57") | str("1566.52") | str("1566.47") | str("1566.42") | str("1566.36") | str("1566.31") | str("1566.26") | str("1566.21") | str("1566.16") | str("1566.11") | str("1566.06") | str("1566.01") | str("1565.96") | str("1565.90") | str("1565.85") | str("1565.80") | str("1565.75") | str("1565.70") | str("1565.65") | str("1565.60") | str("1565.55") | str("1565.50") | str("1565.44") | str("1565.39") | str("1565.34") | str("1565.29") | str("1565.24") | str("1565.19") | str("1565.14") | str("1565.09") | str("1565.04") | str("1564.99") | str("1564.93") | str("1564.88") | str("1564.83") | str("1564.78") | str("1564.73") | str("1564.68") | str("1564.63") | str("1564.58") | str("1564.53") | str("1564.47") | str("1564.42") | str("1564.37") | str("1564.32") | str("1564.27") | str("1564.22") | str("1564.17") | str("1564.12") | str("1564.07") | str("1564.02") | str("1563.96") | str("1563.91") | str("1563.86") | str("1563.81") | str("1563.76") | str("1563.71") | str("1563.66") | str("1563.61") | str("1563.56") | str("1563.51") | str("1563.45") | str("1563.40") | str("1563.35") | str("1563.30") | str("1563.25") | str("1563.20") | str("1563.15") | str("1563.10") | str("1563.05") | str("1563.00") | str("1562.95") | str("1562.89") | str("1562.84") | str("1562.79") | str("1562.74") | str("1562.69") | str("1562.64") | str("1562.59") | str("1562.54") | str("1562.49") | str("1562.44") | str("1562.39") | str("1562.33") | str("1562.28") | str("1562.23") | str("1562.18") | str("1562.13") | str("1562.08") | str("1562.03") | str("1561.98") | str("1561.93") | str("1561.88") | str("1561.83") | str("1561.77") | str("1561.72") | str("1561.67") | str("1561.62") | str("1561.57") | str("1561.52") | str("1561.47") | str("1561.42") | str("1561.37") | str("1561.32") | str("1561.27") | str("1561.22") | str("1561.16") | str("1561.11") | str("1561.06") | str("1561.01") | str("1560.96") | str("1560.91") | str("1560.86") | str("1560.81") | str("1560.76") | str("1560.71") | str("1560.66") | str("1560.61") | str("1560.56") | str("1560.50") | str("1560.45") | str("1560.40") | str("1560.35") | str("1560.30") | str("1560.25") | str("1560.20") | str("1560.15") | str("1560.10") | str("1560.05") | str("1560.00") | str("1559.95") | str("1559.90") | str("1559.84") | str("1559.79") | str("1559.74") | str("1559.69") | str("1559.64") | str("1559.59") | str("1559.54") | str("1559.49") | str("1559.44") | str("1559.39") | str("1559.34") | str("1559.29") | str("1559.24") | str("1559.19") | str("1559.14") | str("1559.08") | str("1559.03") | str("1558.98") | str("1558.93") | str("1558.88") | str("1558.83") | str("1558.78") | str("1558.73") | str("1558.68") | str("1558.63") | str("1558.58") | str("1558.53") | str("1558.48") | str("1558.43") | str("1558.38") | str("1558.32") | str("1558.27") | str("1558.22") | str("1558.17") | str("1558.12") | str("1558.07") | str("1558.02") | str("1557.97") | str("1557.92") | str("1557.87") | str("1557.82") | str("1557.77") | str("1557.72") | str("1557.67") | str("1557.62") | str("1557.57") | str("1557.52") | str("1557.46") | str("1557.41") | str("1557.36") | str("1557.31") | str("1557.26") | str("1557.21") | str("1557.16") | str("1557.11") | str("1557.06") | str("1557.01") | str("1556.96") | str("1556.91") | str("1556.86") | str("1556.81") | str("1556.76") | str("1556.71") | str("1556.66") | str("1556.61") | str("1556.55") | str("1556.50") | str("1556.45") | str("1556.40") | str("1556.35") | str("1556.30") | str("1556.25") | str("1556.20") | str("1556.15") | str("1556.10") | str("1556.05") | str("1556.00") | str("1555.95") | str("1555.90") | str("1555.85") | str("1555.80") | str("1555.75") | str("1555.70") | str("1555.65") | str("1555.60") | str("1555.55") | str("1555.49") | str("1555.44") | str("1555.39") | str("1555.34") | str("1555.29") | str("1555.24") | str("1555.19") | str("1555.14") | str("1555.09") | str("1555.04") | str("1554.99") | str("1554.94") | str("1554.89") | str("1554.84") | str("1554.79") | str("1554.74") | str("1554.69") | str("1554.64") | str("1554.59") | str("1554.54") | str("1554.49") | str("1554.44") | str("1554.39") | str("1554.34") | str("1554.29") | str("1554.23") | str("1554.18") | str("1554.13") | str("1554.08") | str("1554.03") | str("1553.98") | str("1553.93") | str("1553.88") | str("1553.83") | str("1553.78") | str("1553.73") | str("1553.68") | str("1553.63") | str("1553.58") | str("1553.53") | str("1553.48") | str("1553.43") | str("1553.38") | str("1553.33") | str("1553.28") | str("1553.23") | str("1553.18") | str("1553.13") | str("1553.08") | str("1553.03") | str("1552.98") | str("1552.93") | str("1552.88") | str("1552.83") | str("1552.78") | str("1552.73") | str("1552.68") | str("1552.62") | str("1552.57") | str("1552.52") | str("1552.47") | str("1552.42") | str("1552.37") | str("1552.32") | str("1552.27") | str("1552.22") | str("1552.17") | str("1552.12") | str("1552.07") | str("1552.02") | str("1551.97") | str("1551.92") | str("1551.87") | str("1551.82") | str("1551.77") | str("1551.72") | str("1551.67") | str("1551.62") | str("1551.57") | str("1551.52") | str("1551.47") | str("1551.42") | str("1551.37") | str("1551.32") | str("1551.27") | str("1551.22") | str("1551.17") | str("1551.12") | str("1551.07") | str("1551.02") | str("1550.97") | str("1550.92") | str("1550.87") | str("1550.82") | str("1550.77") | str("1550.72") | str("1550.67") | str("1550.62") | str("1550.57") | str("1550.52") | str("1550.47") | str("1550.42") | str("1550.37") | str("1550.32") | str("1550.27") | str("1550.22") | str("1550.17") | str("1550.12") | str("1550.07") | str("1550.02") | str("1549.97") | str("1549.92") | str("1549.87") | str("1549.82") | str("1549.77") | str("1549.72") | str("1549.67") | str("1549.62") | str("1549.57") | str("1549.52") | str("1549.47") | str("1549.42") | str("1549.37") | str("1549.32") | str("1549.26") | str("1549.21") | str("1549.16") | str("1549.11") | str("1549.06") | str("1549.01") | str("1548.96") | str("1548.91") | str("1548.86") | str("1548.81") | str("1548.76") | str("1548.71") | str("1548.66") | str("1548.61") | str("1548.56") | str("1548.51") | str("1548.46") | str("1548.41") | str("1548.36") | str("1548.31") | str("1548.26") | str("1548.21") | str("1548.16") | str("1548.11") | str("1548.06") | str("1548.02") | str("1547.97") | str("1547.92") | str("1547.87") | str("1547.82") | str("1547.77") | str("1547.72") | str("1547.67") | str("1547.62") | str("1547.57") | str("1547.52") | str("1547.47") | str("1547.42") | str("1547.37") | str("1547.32") | str("1547.27") | str("1547.22") | str("1547.17") | str("1547.12") | str("1547.07") | str("1547.02") | str("1546.97") | str("1546.92") | str("1546.87") | str("1546.82") | str("1546.77") | str("1546.72") | str("1546.67") | str("1546.62") | str("1546.57") | str("1546.52") | str("1546.47") | str("1546.42") | str("1546.37") | str("1546.32") | str("1546.27") | str("1546.22") | str("1546.17") | str("1546.12") | str("1546.07") | str("1546.02") | str("1545.97") | str("1545.92") | str("1545.87") | str("1545.82") | str("1545.77") | str("1545.72") | str("1545.67") | str("1545.62") | str("1545.57") | str("1545.52") | str("1545.47") | str("1545.42") | str("1545.37") | str("1545.32") | str("1545.27") | str("1545.22") | str("1545.17") | str("1545.12") | str("1545.07") | str("1545.02") | str("1544.97") | str("1544.92") | str("1544.87") | str("1544.82") | str("1544.77") | str("1544.72") | str("1544.68") | str("1544.63") | str("1544.58") | str("1544.53") | str("1544.48") | str("1544.43") | str("1544.38") | str("1544.33") | str("1544.28") | str("1544.23") | str("1544.18") | str("1544.13") | str("1544.08") | str("1544.03") | str("1543.98") | str("1543.93") | str("1543.88") | str("1543.83") | str("1543.78") | str("1543.73") | str("1543.68") | str("1543.63") | str("1543.58") | str("1543.53") | str("1543.48") | str("1543.43") | str("1543.38") | str("1543.33") | str("1543.28") | str("1543.23") | str("1543.18") | str("1543.13") | str("1543.08") | str("1543.04") | str("1542.99") | str("1542.94") | str("1542.89") | str("1542.84") | str("1542.79") | str("1542.74") | str("1542.69") | str("1542.64") | str("1542.59") | str("1542.54") | str("1542.49") | str("1542.44") | str("1542.39") | str("1542.34") | str("1542.29") | str("1542.24") | str("1542.19") | str("1542.14") | str("1542.09") | str("1542.04") | str("1541.99") | str("1541.94") | str("1541.89") | str("1541.84") | str("1541.80") | str("1541.75") | str("1541.70") | str("1541.65") | str("1541.60") | str("1541.55") | str("1541.50") | str("1541.45") | str("1541.40") | str("1541.35") | str("1541.30") | str("1541.25") | str("1541.20") | str("1541.15") | str("1541.10") | str("1541.05") | str("1541.00") | str("1540.95") | str("1540.90") | str("1540.85") | str("1540.80") | str("1540.76") | str("1540.71") | str("1540.66") | str("1540.61") | str("1540.56") | str("1540.51") | str("1540.46") | str("1540.41") | str("1540.36") | str("1540.31") | str("1540.26") | str("1540.21") | str("1540.16") | str("1540.11") | str("1540.06") | str("1540.01") | str("1539.96") | str("1539.91") | str("1539.86") | str("1539.82") | str("1539.77") | str("1539.72") | str("1539.67") | str("1539.62") | str("1539.57") | str("1539.52") | str("1539.47") | str("1539.42") | str("1539.37") | str("1539.32") | str("1539.27") | str("1539.22") | str("1539.17") | str("1539.12") | str("1539.07") | str("1539.03") | str("1538.98") | str("1538.93") | str("1538.88") | str("1538.83") | str("1538.78") | str("1538.73") | str("1538.68") | str("1538.63") | str("1538.58") | str("1538.53") | str("1538.48") | str("1538.43") | str("1538.38") | str("1538.33") | str("1538.28") | str("1538.24") | str("1538.19") | str("1538.14") | str("1538.09") | str("1538.04") | str("1537.99") | str("1537.94") | str("1537.89") | str("1537.84") | str("1537.79") | str("1537.74") | str("1537.69") | str("1537.64") | str("1537.59") | str("1537.55") | str("1537.50") | str("1537.45") | str("1537.40") | str("1537.35") | str("1537.30") | str("1537.25") | str("1537.20") | str("1537.15") | str("1537.10") | str("1537.05") | str("1537.00") | str("1536.95") | str("1536.90") | str("1536.86") | str("1536.81") | str("1536.76") | str("1536.71") | str("1536.66") | str("1536.61") | str("1536.56") | str("1536.51") | str("1536.46") | str("1536.41") | str("1536.36") | str("1536.31") | str("1536.26") | str("1536.22") | str("1536.17") | str("1536.12") | str("1536.07") | str("1536.02") | str("1535.97") | str("1535.92") | str("1535.87") | str("1535.82") | str("1535.77") | str("1535.72") | str("1535.67") | str("1535.63") | str("1535.58") | str("1535.53") | str("1535.48") | str("1535.43") | str("1535.38") | str("1535.33") | str("1535.28") | str("1535.23") | str("1535.18") | str("1535.13") | str("1535.08") | str("1535.04") | str("1534.99") | str("1534.94") | str("1534.89") | str("1534.84") | str("1534.79") | str("1534.74") | str("1534.69") | str("1534.64") | str("1534.59") | str("1534.54") | str("1534.50") | str("1534.45") | str("1534.40") | str("1534.35") | str("1534.30") | str("1534.25") | str("1534.20") | str("1534.15") | str("1534.10") | str("1534.05") | str("1534.00") | str("1533.96") | str("1533.91") | str("1533.86") | str("1533.81") | str("1533.76") | str("1533.71") | str("1533.66") | str("1533.61") | str("1533.56") | str("1533.51") | str("1533.47") | str("1533.42") | str("1533.37") | str("1533.32") | str("1533.27") | str("1533.22") | str("1533.17") | str("1533.12") | str("1533.07") | str("1533.02") | str("1532.98") | str("1532.93") | str("1532.88") | str("1532.83") | str("1532.78") | str("1532.73") | str("1532.68") | str("1532.63") | str("1532.58") | str("1532.53") | str("1532.49") | str("1532.44") | str("1532.39") | str("1532.34") | str("1532.29") | str("1532.24") | str("1532.19") | str("1532.14") | str("1532.09") | str("1532.04") | str("1532.00") | str("1531.95") | str("1531.90") | str("1531.85") | str("1531.80") | str("1531.75") | str("1531.70") | str("1531.65") | str("1531.60") | str("1531.56") | str("1531.51") | str("1531.46") | str("1531.41") | str("1531.36") | str("1531.31") | str("1531.26") | str("1531.21") | str("1531.16") | str("1531.12") | str("1531.07") | str("1531.02") | str("1530.97") | str("1530.92") | str("1530.87") | str("1530.82") | str("1530.77") | str("1530.72") | str("1530.68") | str("1530.63") | str("1530.58") | str("1530.53") | str("1530.48") | str("1530.43") | str("1530.38") | str("1530.33") | str("1530.29") | str("1530.24") | str("1530.19") | str("1530.14") | str("1530.09") | str("1530.04") | str("1529.99") | str("1529.94") | str("1529.89") | str("1529.85") | str("1529.80") | str("1529.75") | str("1529.70") | str("1529.65") | str("1529.60") | str("1529.55") | str("1529.50") | str("1529.46") | str("1529.41") | str("1529.36") | str("1529.31") | str("1529.26") | str("1529.21") | str("1529.16") | str("1529.11") | str("1529.07") | str("1529.02") | str("1528.97") | str("1528.92") | str("1528.87") | str("1528.82") | str("1528.77") | str("1528.38"))
                    ),
                    a(str("tx-power"), arg),
                    str("loopback"),
                    a(str("los-warning-threshold"), arg),
                    a(str("los-alarm-threshold"), arg),
                    b(str("modulation-format"),
                      (str("16qam") | str("8qam") | str("qpsk"))
                    ),
                    str("laser-enable"),
                    str("no-laser-enable"),
                    str("is-ma"),
                    str("no-is-ma"),
                    b(str("encoding"),
                      (str("differential") | str("non-differential"))
                    ),
                    b(str("fec"),
                      (str("sdfec") | str("sdfec25") | str("hgfec") | str("sdfec15"))
                    ),
                    str("high-polarization"),
                    b(str("signal-degrade"),
                        c(
                            a(str("interval"), arg),
                            a(str("ber-threshold-clear"), arg),
                            a(str("ber-threshold-signal-degrade"), arg),
                            a(str("q-threshold-signal-degrade-clear"), arg),
                            a(str("q-threshold-signal-degrade"), arg)
                        )
                    ),
                    a(str("alarm"), enum(str("low-light-alarm")),
                        c(
                            c(
                              str("syslog"),
                              str("link-down")
                            )
                        )
                    ),
                    b(str("tca"),
                        c(
                            b(str("tx-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("tx-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("rx-power-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("rx-power-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("temperature-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("temperature-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("carrier-frequency-offset-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("carrier-frequency-offset-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("fec-ber"),
                                sc(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ).as(:oneline),
                            b(str("tec-current-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("tec-current-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("residual-isi-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("residual-isi-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("pam-histogram-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("snr-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("fec-corrected-errors-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("fec-ucorrected-words-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("laser-frequency-error-high-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            ),
                            b(str("laser-frequency-error-low-tca"),
                                c(
                                    str("enable-tca"),
                                    str("no-enable-tca"),
                                    a(str("threshold"), arg),
                                    a(str("threshold-24hrs"), arg)
                                )
                            )
                        )
                    ),
                    a(str("warning"), enum(str("low-light-warning")),
                        c(
                            c(
                              str("syslog"),
                              str("link-down")
                            )
                        )
                    )
                )
            ),
            b(str("otn-options"),
              otn_options_type
            ),
            b(str("och-options"),
              och_attributes
            ),
            b(str("otu-options"),
              otu_attributes
            ),
            b(str("odu-options"),
              odu_attributes
            ),
            b(str("ett-options"),
              ett_attributes
            ),
            b(str("fastether-options"),
                c(
                    str("loopback"),
                    str("no-loopback"),
                    str("flow-control"),
                    str("no-flow-control"),
                    str("source-filtering"),
                    str("no-source-filtering"),
                    str("auto-negotiation"),
                    str("no-auto-negotiation"),
                    a(str("ingress-rate-limit"), arg),
                    a(str("source-address-filter"), arg).as(:oneline),
                    b(str("redundant-parent"),
                        c(
                              interface_device
                        )
                    ),
                    b(str("802.3ad"),
                        c(
                            b(str("lacp"),
                                c(
                                    a(str("port-priority"), arg)
                                )
                            ),
                              interface_device,
                            c(
                              str("primary"),
                              str("backup")
                            )
                        )
                    ),
                    b(str("mpls"),
                      mpls_ifd_options
                    ),
                    str("ignore-l3-incompletes")
                )
            ),
            b(str("redundant-ether-options"),
                c(
                    a(str("redundancy-group"), arg),
                    str("loopback"),
                    str("no-loopback"),
                    str("flow-control"),
                    str("no-flow-control"),
                    str("source-filtering"),
                    str("no-source-filtering"),
                    a(str("source-address-filter"), arg).as(:oneline),
                    b(str("link-speed"),
                      (str("10m") | str("100m") | str("1g") | str("10g"))
                    ),
                    a(str("minimum-links"), arg),
                    b(str("lacp"),
                        c(
                            c(
                              str("active"),
                              str("passive")
                            ),
                            b(str("periodic"),
                              (str("fast") | str("slow"))
                            )
                        )
                    )
                )
            ),
            b(str("aggregated-ether-options"),
                c(
                    str("loopback"),
                    str("no-loopback"),
                    str("flow-control"),
                    str("no-flow-control"),
                    str("source-filtering"),
                    str("no-source-filtering"),
                    str("autostate-exclude"),
                    b(str("link-protection"),
                        c(
                            str("revertive"),
                            str("non-revertive"),
                            b(str("backup-state"),
                              (str("accept-data") | str("discard-data") | str("down"))
                            ),
                            b(str("rtg-config"),
                                c(
                                    a(str("preempt-cutover-timer"), arg)
                                )
                            )
                        )
                    ),
                    str("fcoe-lag"),
                    str("no-fcoe-lag"),
                    a(str("source-address-filter"), arg).as(:oneline),
                    b(str("configured-flow-control"),
                        c(
                            b(str("rx-buffers"),
                              (str("on") | str("off"))
                            ),
                            b(str("tx-buffers"),
                              (str("on") | str("off"))
                            )
                        )
                    ),
                    b(str("load-balance"),
                      aggregate_load_balance
                    ),
                    b(str("bfd-liveness-detection"),
                        c(
                            b(str("version"),
                              (str("0") | str("1") | str("automatic"))
                            ),
                            a(str("minimum-interval"), arg),
                            a(str("minimum-transmit-interval"), arg),
                            a(str("minimum-receive-interval"), arg),
                            a(str("multiplier"), arg),
                            c(
                              str("no-adaptation")
                            ),
                            b(str("transmit-interval"),
                                c(
                                    a(str("minimum-interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("detection-time"),
                                c(
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("authentication"),
                                c(
                                    a(str("key-chain"), arg),
                                    b(str("algorithm"),
                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                    ),
                                    str("loose-check")
                                )
                            ),
                            b(str("neighbor"),
                              ipaddr
                            ),
                            b(str("local-address"),
                              ipaddr
                            ),
                            a(str("holddown-interval"), arg)
                        )
                    ),
                    a(str("minimum-links"), arg),
                    b(str("minimum-bandwidth"),
                        c(
                            a(str("bw-value"), arg),
                            b(str("bw-unit"),
                              (str("bps") | str("kbps") | str("mbps") | str("gbps"))
                            )
                        )
                    ),
                    b(str("targeted-options"),
                        c(
                            b(str("type"),
                              (str("auto") | str("manual"))
                            ),
                            c(
                              str("logical-interface-fpc-redundancy"),
                              str("logical-interface-chassis-redundancy")
                            ),
                            b(str("rebalance-periodic"),
                                c(
                                    b(str("start-time"),
                                      date
                                    ),
                                    a(str("interval"), arg)
                                )
                            ),
                            a(str("rebalance-subscriber-granularity"), arg)
                        )
                    ),
                    c(
                      str("logical-interface-fpc-redundancy"),
                      str("logical-interface-chassis-redundancy")
                    ),
                    b(str("rebalance-periodic"),
                        c(
                            b(str("start-time"),
                              date
                            ),
                            a(str("interval"), arg)
                        )
                    ),
                    str("pad-to-minimum-frame-size"),
                    b(str("link-speed"),
                      (str("10m") | str("100m") | str("1g") | str("2.5g") | str("5g") | str("8g") | str("10g") | str("25g") | str("40g") | str("50g") | str("80g") | str("100g") | str("400g") | str("oc192") | str("mixed"))
                    ),
                    b(str("local-bias"),
                        c(
                            str("disable")
                        )
                    ),
                    a(str("local-minimum-links-threshold"), arg),
                    str("resilient-hash"),
                    b(str("lacp"),
                        c(
                            c(
                              str("active"),
                              str("passive")
                            ),
                            b(str("periodic"),
                              (str("fast") | str("slow"))
                            ),
                            str("fast-failover"),
                            b(str("link-protection"),
                                c(
                                    str("disable"),
                                    c(
                                      str("revertive"),
                                      str("non-revertive")
                                    ),
                                    b(str("rtg-config"),
                                        c(
                                            a(str("preempt-cutover-timer"), arg)
                                        )
                                    )
                                )
                            ),
                            str("accept-data"),
                            b(str("sync-reset"),
                              (str("disable") | str("enable"))
                            ),
                            a(str("system-priority"), arg),
                            b(str("system-id"),
                              mac_addr
                            ),
                            a(str("admin-key"), arg),
                            b(str("hold-time"),
                                sc(
                                    a(str("up"), arg)
                                )
                            ).as(:oneline),
                            a(str("aggregate-wait-time"), arg),
                            str("force-up"),
                            str("no-peer-loopback-validation")
                        )
                    ),
                    b(a(str("link-protection-sub-group"), arg),
                        c(
                            c(
                              str("primary"),
                              str("backup")
                            )
                        )
                    ),
                    b(str("ethernet-switch-profile"),
                        c(
                            a(str("tag-protocol-id"), arg),
                            b(str("storm-control"),
                                c(
                                    arg
                                )
                            ),
                            str("mac-learn-enable")
                        )
                    ),
                    b(str("mc-ae"),
                        c(
                            a(str("mc-ae-id"), arg),
                            a(str("redundancy-group"), arg),
                            a(str("chassis-id"), arg),
                            b(str("mode"),
                              (str("active-standby") | str("active-active"))
                            ),
                            b(str("status-control"),
                              (str("active") | str("standby"))
                            ),
                            b(str("switchover-mode"),
                              (str("revertive") | str("non-revertive"))
                            ),
                            a(str("revert-time"), arg),
                            a(str("init-delay-time"), arg),
                            a(str("recovery-delay-time"), arg),
                            str("enhanced-convergence"),
                            b(str("events"),
                                c(
                                    b(str("iccp-peer-down"),
                                        c(
                                            str("force-icl-down"),
                                            str("prefer-status-control-active")
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("share-standby")
                )
            ),
            b(str("es-options"),
                c(
                    b(str("backup-interface"),
                      interface_device
                    )
                )
            ),
            b(str("dsl-options"),
                c(
                    b(str("operating-mode"),
                      (str("auto") | str("ansi-dmt") | str("itu-dmt") | str("etsi") | str("itu-annexb-ur2") | str("itu-annexb-non-ur2") | str("itu-dmt-bis") | str("adsl2plus") | str("annexm-itu-dmt-bis") | str("annexm-adsl2plus"))
                    )
                )
            ),
            b(str("vdsl-options"),
                c(
                    b(str("vdsl-profile"),
                      (str("auto") | str("8a") | str("8b") | str("8c") | str("8d") | str("12a") | str("12b") | str("17a"))
                    ),
                    b(str("sra"),
                      (str("enable") | str("disable"))
                    ),
                    b(str("v43"),
                      (str("enable") | str("disable"))
                    ),
                    str("sos")
                )
            ),
            b(str("dsl-sfp-options"),
                c(
                    b(str("adsl-options"),
                        c(
                            a(str("vpi"), arg),
                            a(str("vci"), arg),
                            b(str("encap"),
                              (str("bypass") | str("llcsnap-bridged-802dot1q") | str("llcsnap-routed-ip") | str("vc-mux-bridged") | str("vc-mux-routed-ip") | str("generic"))
                            )
                        )
                    ),
                    b(str("vdsl-options"),
                        c(
                            b(str("profile"),
                              (str("auto") | str("8a") | str("8b") | str("8c") | str("8d") | str("12a") | str("12b") | str("17a") | str("30a"))
                            ),
                            b(str("carrier"),
                              (str("auto") | str("a43") | str("b43"))
                            )
                        )
                    )
                )
            ),
            b(str("shdsl-options"),
                c(
                    b(str("annex"),
                      (str("annex-a") | str("annex-b") | str("annex-f") | str("annex-g") | str("annex-auto"))
                    ),
                    b(str("line-rate"),
                      (str("auto") | arg)
                    ),
                    b(str("loopback"),
                      (str("local") | str("remote"))
                    ),
                    b(str("snr-margin"),
                        c(
                            b(str("current"),
                              (str("disable") | arg)
                            ),
                            b(str("snext"),
                              (str("disable") | arg)
                            )
                        )
                    )
                )
            ),
            b(str("data-input"),
                c(
                    c(
                      str("system"),
                      b(str("interface"),
                        interface_device
                      )
                    )
                )
            ),
            b(str("switch-options"),
                c(
                    b(a(str("switch-port"), arg),
                        c(
                            str("auto-negotiation"),
                            str("no-auto-negotiation"),
                            b(str("link-mode"),
                              (str("half-duplex") | str("full-duplex"))
                            ),
                            b(str("speed"),
                              (str("10m") | str("100m") | str("1g"))
                            ),
                            a(str("vlan-id"), arg),
                            str("cascade-port")
                        )
                    )
                )
            ),
            b(str("container-options"),
                c(
                    b(str("container-type"),
                        c(
                            c(
                              b(str("aps"),
                                aps_type
                              )
                            )
                        )
                    ),
                    b(str("member-interface-type"),
                        c(
                            c(
                              b(str("sonet"),
                                  c(
                                      b(str("member-interface-speed"),
                                        (str("oc3") | str("oc12") | str("oc48") | str("oc192") | str("oc768") | str("mixed"))
                                      )
                                  )
                              ),
                              b(str("atm"),
                                  c(
                                      b(str("member-interface-speed"),
                                        (str("oc3") | str("oc12") | str("oc48"))
                                      )
                                  )
                              ),
                              b(str("channelized-sonet"),
                                  c(
                                      b(str("member-interface-speed"),
                                        (str("coc3") | str("coc12") | str("coc48") | str("coc192") | str("coc768"))
                                      )
                                  )
                              ),
                              b(str("channelized-sdh"),
                                  c(
                                      b(str("member-interface-speed"),
                                        (str("cstm1") | str("cstm4") | str("cstm16") | str("coc64") | str("cstm256"))
                                      )
                                  )
                              )
                            )
                        )
                    ),
                    b(str("redundancy"),
                        c(
                            b(str("hold-time"),
                                sc(
                                    a(str("up"), arg),
                                    a(str("down"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("container-list"),
                      interface_device
                    ),
                    c(
                        str("primary"),
                        str("standby")
                    ),
                    str("fast-aps"),
                    str("allow-configuration-override")
                )
            ),
            b(str("layer2-policer"),
                c(
                    c(
                      a(str("input-policer"), arg),
                      a(str("input-hierarchical-policer"), arg)
                    )
                )
            ),
            a(str("unit"), enum(arg | arg | arg),
                c(
                    b(str("policer-overhead"),
                        ca(
                            a(str("ingress"), arg),
                            a(str("egress"), arg)
                        )
                    ),
                    a(str("alias"), arg),
                    str("enhanced-convergence"),
                    str("proxy-macip-advertisement"),
                    str("virtual-gateway-accept-data"),
                    b(str("peer-psd"),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(str("peer-interface"),
                        c(
                              interface_unit
                        )
                    ),
                    b(str("interface-shared-with"),
                        c(
                            arg
                        )
                    ),
                      (str("disable")),
                    str("passive-monitor-mode"),
                    str("per-session-scheduler"),
                    b(str("account-layer2-overhead"),
                        ca(
                            a(str("ingress"), arg),
                            a(str("egress"), arg)
                        )
                    ),
                    b(str("forwarding-class-accounting"),
                        c(
                            b(str("direction"),
                              (str("ingress") | str("egress") | str("both"))
                            ),
                            b(str("enhanced"),
                                c(
                                    b(str("traffic-type"),
                                      (str("unicast-statistics") | str("multicast-statistics"))
                                    ),
                                    b(str("family"),
                                      (str("inet6") | str("inet") | str("both"))
                                    ),
                                    b(str("direction"),
                                      (str("ingress") | str("egress") | str("both"))
                                    ),
                                    a(str("overhead-bytes"), arg)
                                )
                            )
                        )
                    ),
                    str("clear-dont-fragment-bit"),
                    str("packet-inject-enable"),
                    str("reassemble-packets"),
                    str("services-options"),
                    b(str("rpm"),
                        c(
                            c(
                              c(
                                str("client"),
                                str("server"),
                                str("client-delegate-probes")
                              ),
                              str("twamp-server"),
                              str("twamp-client")
                            )
                        )
                    ),
                    a(str("description"), quote | arg),
                    a(str("metadata"), arg),
                    b(str("dial-options"),
                        c(
                            c(
                              a(str("l2tp-interface-id"), arg),
                              a(str("ipsec-interface-id"), arg)
                            ),
                            c(
                              str("dedicated"),
                              str("shared")
                            )
                        )
                    ),
                    str("actual-transit-statistics"),
                    b(str("demux-source"),
                          enum((str("inet6") | str("inet")))
                    ),
                    b(str("demux-destination"),
                          enum((str("inet6") | str("inet")))
                    ),
                    b(str("demux"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("address"),
                                      (str("source") | str("destination"))
                                    ),
                                    b(str("auto-configure"),
                                      dynamic_ipv4_type
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("address"),
                                      (str("source") | str("destination"))
                                    ),
                                    b(str("auto-configure"),
                                      dynamic_ipv6_type
                                    )
                                )
                            )
                        )
                    ),
                    b(str("encapsulation"),
                      (str("atm-nlpid") | str("atm-cisco-nlpid") | str("atm-snap") | str("atm-vc-mux") | str("atm-ccc-vc-mux") | str("atm-tcc-vc-mux") | str("atm-tcc-snap") | str("atm-ccc-cell-relay") | str("vlan-vci-ccc") | str("ether-over-atm-llc") | str("ether-vpls-over-atm-llc") | str("ppp-over-ether-over-atm-llc") | str("ppp-over-ether") | str("atm-ppp-vc-mux") | str("atm-ppp-llc") | str("atm-mlppp-llc") | str("frame-relay-ppp") | str("frame-relay-ccc") | str("frame-relay") | str("frame-relay-tcc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("ether-vpls-fr") | str("vlan-ccc") | str("ethernet-ccc") | str("vlan-vpls") | str("vlan-bridge") | str("dix") | str("ethernet-vpls") | str("ethernet-bridge") | str("ethernet") | str("vlan") | str("vlan-tcc") | str("multilink-ppp") | str("multilink-frame-relay-end-to-end") | str("ppp-ccc"))
                    ),
                    str("gre"),
                    a(str("mtu"), arg),
                    c(
                      str("point-to-point"),
                      str("multipoint")
                    ),
                    a(str("bandwidth"), arg),
                    a(str("global-layer2-domainid"), arg),
                    b(str("radio-router"),
                      dynamic_ifbw_parms_type
                    ),
                    str("traps"),
                    str("no-traps"),
                    str("routing-services"),
                    str("no-routing-services"),
                    b(str("routing-service"),
                        c(
                              (str("enable") | str("disable"))
                        )
                    ),
                    b(str("arp-resp"),
                        sc(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    b(str("proxy-arp"),
                        sc(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    c(
                      b(str("vlan-id"),
                        (str("none") | arg)
                      ),
                      a(str("vlan-id-range"), arg),
                      a(str("inner-vlan-id-swap-ranges"), arg),
                      a(str("vlan-id-list"), arg),
                      a(str("vlan-tag"), arg),
                      b(str("vlan-tags"),
                          sc(
                              b(str("outer"),
                                (arg | arg | arg)
                              ),
                              c(
                                b(str("inner"),
                                  (arg | arg)
                                ),
                                a(str("inner-range"), arg),
                                a(str("inner-list"), arg)
                              )
                          )
                      ).as(:oneline)
                    ),
                    a(str("deep-vlan-qualified-learning"), arg),
                    a(str("native-inner-vlan-id"), arg),
                    b(str("inner-vlan-id-range"),
                        sc(
                            a(str("start"), arg),
                            a(str("end"), arg)
                        )
                    ).as(:oneline),
                    b(str("accept-source-mac"),
                        c(
                            b(str("mac-address"),
                              mac_list
                            )
                        )
                    ),
                    b(str("input-vlan-map"),
                      vlan_map
                    ),
                    b(str("output-vlan-map"),
                      vlan_map
                    ),
                    str("swap-by-poppush"),
                    a(str("receive-lsp"), arg),
                    a(str("transmit-lsp"), arg),
                    a(str("dlci"), arg),
                    a(str("multicast-dlci"), arg),
                    c(
                      b(str("vci"),
                        atm_vci
                      ),
                      str("allow-any-vci"),
                      a(str("vpi"), arg),
                      a(str("trunk-id"), arg)
                    ),
                    str("no-vpivci-swapping"),
                    c(
                      b(str("psn-vci"),
                        atm_vci
                      ),
                      a(str("psn-vpi"), arg)
                    ),
                    b(str("atm-l2circuit-mode"),
                        sc(
                            c(
                              str("cell"),
                              str("aal5")
                            )
                        )
                    ).as(:oneline),
                    b(str("vci-range"),
                        sc(
                            a(str("start"), arg),
                            a(str("end"), arg)
                        )
                    ).as(:oneline),
                    a(str("trunk-bandwidth"), arg),
                    b(str("multicast-vci"),
                      atm_vci
                    ),
                    b(str("shaping"),
                      dcd_shaping_config
                    ),
                    b(str("oam-period"),
                        sc(
                            ca(
                              str("disable").as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oam-liveness"),
                        c(
                            a(str("up-count"), arg),
                            a(str("down-count"), arg)
                        )
                    ),
                    b(str("ppp-options"),
                      ppp_options_type
                    ),
                    b(str("pppoe-options"),
                      pppoe_options_type
                    ),
                    b(str("pppoe-underlying-options"),
                      pppoe_underlying_options_type
                    ),
                    b(str("advisory-options"),
                      advisory_options_type
                    ),
                    b(str("auto-configure"),
                      auto_configure_vlan_type
                    ),
                    b(str("demux-options"),
                      demux_options_type
                    ),
                    b(str("targeted-distribution"),
                        c(
                            a(str("primary-list"), arg),
                            a(str("backup-list"), arg),
                            a(str("standby-list"), arg)
                        )
                    ),
                    b(str("targeted-options"),
                        c(
                            b(str("weight"),
                              (arg | arg)
                            ),
                            b(str("primary"),
                              interface_device
                            ),
                            b(str("backup"),
                              interface_device
                            ),
                            a(str("group"), arg)
                        )
                    ),
                    c(
                      b(str("keepalives"),
                        keepalives_type
                      ).as(:oneline),
                      str("no-keepalives")
                    ),
                    str("inverse-arp"),
                    a(str("transmit-weight"), arg),
                    b(str("epd-threshold"),
                      epd_threshold_config
                    ).as(:oneline),
                    a(str("cell-bundle-size"), arg),
                    a(str("cell-bundle-timeout"), arg),
                    str("plp-to-clp"),
                    a(str("atm-scheduler-map"), arg),
                    a(str("mrru"), arg),
                    str("short-sequence"),
                    a(str("fragment-threshold"), arg),
                    a(str("drop-timeout"), arg),
                    str("disable-mlppp-inner-ppp-pfc"),
                    a(str("minimum-links"), arg),
                    a(str("multilink-max-classes"), arg),
                    b(str("compression"),
                        c(
                            b(str("rtp"),
                                c(
                                    a(str("f-max-period"), arg),
                                    b(str("queues"),
                                      (str("q0") | str("q1") | str("q2") | str("q3"))
                                    ),
                                    b(str("port"),
                                        sc(
                                            a(str("minimum"), arg),
                                            a(str("maximum"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("maximum-contexts"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    str("interleave-fragments"),
                    b(str("link-layer-overhead"),
                      unsigned_float
                    ),
                    a(str("accounting-profile"), arg),
                    a(str("peer-unit"), arg),
                    b(str("tunnel"),
                        c(
                            b(str("encapsulation"),
                                c(
                                    b(str("vxlan-gpe"),
                                        c(
                                            b(str("source"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    ),
                                                    b(str("interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("tunnel-endpoint"),
                                              (str("vxlan"))
                                            ),
                                            a(str("destination-udp-port"), arg),
                                            a(str("vni"), arg)
                                        )
                                    ),
                                    b(str("udp"),
                                        c(
                                            b(str("source"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    ),
                                                    b(str("interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("source"),
                              ipaddr
                            ),
                            b(str("destination"),
                              ipaddr
                            ),
                            a(str("key"), arg),
                            b(str("backup-destination"),
                              ipaddr
                            ),
                            c(
                              str("allow-fragmentation"),
                              str("do-not-fragment")
                            ),
                            a(str("ttl"), arg),
                            a(str("traffic-class"), arg),
                            a(str("flow-label"), arg),
                            str("path-mtu-discovery"),
                            str("no-path-mtu-discovery"),
                            b(str("routing-instance"),
                                c(
                                    a(str("destination"), arg)
                                )
                            )
                        )
                    ),
                    b(str("compression-device"),
                      interface_unit
                    ),
                    b(str("atm-policer"),
                        c(
                            a(str("input-atm-policer"), arg)
                        )
                    ),
                    b(str("layer2-policer"),
                        c(
                            c(
                              a(str("input-policer"), arg),
                              a(str("input-hierarchical-policer"), arg),
                              a(str("input-three-color"), arg)
                            ),
                            c(
                              b(str("output-policer"),
                                (arg | arg)
                              ),
                              b(str("output-three-color"),
                                (arg | arg)
                              )
                            )
                        )
                    ),
                    b(str("filter"),
                        c(
                            c(
                              b(str("input"),
                                  sc(
                                      arg,
                                      a(str("shared-name"), arg),
                                      a(str("precedence"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            c(
                              b(str("output"),
                                  sc(
                                      arg,
                                      a(str("shared-name"), arg),
                                      a(str("precedence"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ),
                    b(str("multi-chassis-protection"),
                      multi_chassis_protection_group_ifl
                    ),
                    str("statistics"),
                    b(str("esi"),
                        c(
                            b(str("auto-derive"),
                                c(
                                    c(
                                      str("lacp")
                                    )
                                )
                            ),
                              esi,
                            c(
                              str("single-active"),
                              str("all-active")
                            ),
                            b(str("df-election-type"),
                                c(
                                    c(
                                      b(str("preference"),
                                          c(
                                              a(str("value"), arg)
                                          )
                                      )
                                    ),
                                    c(
                                      str("mod")
                                    )
                                )
                            ),
                            b(str("source-bmac"),
                              mac_unicast
                            )
                        )
                    ),
                    c(
                      str("no-auto-virtual-gateway-esi"),
                      b(str("virtual-gateway-esi"),
                          c(
                                esi,
                              c(
                                str("single-active"),
                                str("all-active")
                              )
                          )
                      )
                    ),
                    b(str("service"),
                        c(
                            b(a(str("pcef"), arg),
                                c(
                                    str("activate-all"),
                                    a(str("activate"), arg)
                                )
                            )
                        )
                    ),
                    str("generate-eui64"),
                    str("no-generate-eui64"),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("dhcp"),
                                      dhcp_client_type
                                    ),
                                    b(str("targeted-broadcast"),
                                        c(
                                            c(
                                              str("forward-and-send-to-re"),
                                              str("forward-only")
                                            )
                                        )
                                    ),
                                    str("destination-class-usage"),
                                    str("transit-options-packets"),
                                    str("transit-ttl-exceeded"),
                                    str("receive-options-packets"),
                                    str("receive-ttl-exceeded"),
                                    b(str("accounting"),
                                        c(
                                            b(str("source-class-usage"),
                                                c(
                                                    str("input"),
                                                    str("output")
                                                )
                                            ),
                                            str("destination-class-usage")
                                        )
                                    ),
                                    b(str("mac-validate"),
                                      (str("strict") | str("loose"))
                                    ),
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                sc(
                                                    str("loose")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    a(str("mtu"), arg),
                                    a(str("arp-max-cache"), arg),
                                    a(str("arp-new-hold-limit"), arg),
                                    a(str("tcp-mss"), arg),
                                    str("no-redirects"),
                                    str("no-neighbor-learn"),
                                    str("unconditional-src-learn"),
                                    str("multicast-only"),
                                    str("primary"),
                                    a(str("ipsec-sa"), arg),
                                    str("allow-filter-on-re"),
                                    a(str("demux-source"), arg | arg),
                                    a(str("demux-destination"), arg | arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("simple-filter"),
                                        c(
                                            a(str("input"), arg)
                                        )
                                    ),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("arp"), arg),
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    ),
                                    b(str("service"),
                                        c(
                                            b(str("input"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    ),
                                                    a(str("post-service-filter"), arg)
                                                )
                                            ),
                                            b(str("output"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("next-hop-tunnel"), arg),
                                        c(
                                            a(str("ipsec-vpn"), arg)
                                        )
                                    ),
                                    b(a(str("address"), arg),
                                        c(
                                            b(str("destination"),
                                              ipv4addr
                                            ),
                                            a(str("destination-profile"), arg),
                                            b(str("broadcast"),
                                              ipv4addr
                                            ),
                                            str("primary"),
                                            str("preferred"),
                                            str("master-only"),
                                            b(a(str("multipoint-destination"), arg),
                                                c(
                                                    c(
                                                      a(str("dlci"), arg),
                                                      b(str("vci"),
                                                        atm_vci
                                                      )
                                                    ),
                                                    b(str("shaping"),
                                                      dcd_shaping_config
                                                    ),
                                                    b(str("oam-period"),
                                                        sc(
                                                            ca(
                                                              str("disable").as(:oneline)
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    b(str("oam-liveness"),
                                                        c(
                                                            a(str("up-count"), arg),
                                                            a(str("down-count"), arg)
                                                        )
                                                    ),
                                                    str("inverse-arp"),
                                                    a(str("transmit-weight"), arg),
                                                    b(str("epd-threshold"),
                                                      epd_threshold_config
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(a(str("arp"), arg),
                                                sc(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicast
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(a(str("host-discovery"), arg),
                                                sc(
                                                    a(str("aging-timer"), arg),
                                                    a(str("discovery-interval"), arg)
                                                )
                                            ).as(:oneline),
                                            b(str("web-authentication"),
                                                c(
                                                    str("https"),
                                                    str("http"),
                                                    str("redirect-to-https")
                                                )
                                            ),
                                            b(str("vrrp-group"),
                                              vrrp_group
                                            ),
                                            b(str("virtual-gateway-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("unnumbered-address"),
                                        sc(
                                              interface_unit,
                                            b(str("preferred-source-address"),
                                              (arg | arg)
                                            ),
                                            b(str("destination"),
                                              ipv4addr
                                            ),
                                            a(str("destination-profile"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("location-pool-address"),
                                        c(
                                              arg
                                        )
                                    ),
                                    str("negotiate-address"),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("iso"),
                                c(
                                    a(str("address"), arg),
                                    a(str("mtu"), arg),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("dhcpv6-client"),
                                        c(
                                            b(str("client-type"),
                                              (str("stateful") | str("autoconfig"))
                                            ),
                                            a(str("client-ia-type"), enum(str("ia-na") | str("ia-pd"))),
                                            str("rapid-commit"),
                                            b(str("prefix-delegating"),
                                                c(
                                                    a(str("preferred-prefix-length"), arg),
                                                    a(str("sub-prefix-length"), arg)
                                                )
                                            ),
                                            b(str("client-identifier"),
                                                sc(
                                                    b(str("duid-type"),
                                                      (str("duid-llt") | str("vendor") | str("duid-ll"))
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("req-option"), enum(str("dns-server") | str("domain") | str("ntp-server") | str("time-zone") | str("sip-server") | str("sip-domain") | str("nis-server") | str("nis-domain") | str("fqdn") | str("vendor-spec") | str("zero-touch-redirect"))),
                                            b(str("options"),
                                                c(
                                                    b(a(str("number"), arg),
                                                        sc(
                                                            c(
                                                              a(str("hex-string"), arg)
                                                            )
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("retransmission-attempt"), arg),
                                            str("no-dns-install"),
                                            b(str("update-router-advertisement"),
                                                c(
                                                    b(a(str("interface"), arg),
                                                        c(
                                                            str("managed-configuration"),
                                                            str("no-managed-configuration"),
                                                            str("other-stateful-configuration"),
                                                            str("no-other-stateful-configuration"),
                                                            a(str("max-advertisement-interval"), arg),
                                                            a(str("min-advertisement-interval"), arg),
                                                            str("enable-recursive-dns-server-option"),
                                                            str("no-enable-recursive-dns-server-option")
                                                        )
                                                    )
                                                )
                                            ),
                                            str("update-server")
                                        )
                                    ),
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                sc(
                                                    str("loose")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("accounting"),
                                        c(
                                            b(str("source-class-usage"),
                                                c(
                                                    str("input"),
                                                    str("output")
                                                )
                                            ),
                                            str("destination-class-usage")
                                        )
                                    ),
                                    a(str("mtu"), arg),
                                    a(str("tcp-mss"), arg),
                                    a(str("nd6-stale-time"), arg),
                                    str("no-neighbor-learn"),
                                    str("slaac-enable"),
                                    b(str("ndp-proxy"),
                                        c(
                                            str("interface-restricted")
                                        )
                                    ),
                                    b(str("dad-proxy"),
                                        c(
                                            str("interface-restricted")
                                        )
                                    ),
                                    a(str("nd6-max-cache"), arg),
                                    a(str("nd6-new-hold-limit"), arg),
                                    str("no-redirects"),
                                    str("allow-filter-on-re"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    ),
                                    b(str("service"),
                                        c(
                                            b(str("input"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    ),
                                                    a(str("post-service-filter"), arg)
                                                )
                                            ),
                                            b(str("output"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("address"), arg),
                                        c(
                                            b(str("destination"),
                                              ipv6addr
                                            ),
                                            str("eui-64"),
                                            str("primary"),
                                            str("preferred"),
                                            str("master-only"),
                                            b(a(str("ndp"), arg),
                                                sc(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicast
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(str("vrrp-inet6-group"),
                                              vrrp_group
                                            ),
                                            b(str("web-authentication"),
                                                c(
                                                    str("https"),
                                                    str("http"),
                                                    str("redirect-to-https")
                                                )
                                            ),
                                            b(str("virtual-gateway-address"),
                                              ipv6addr
                                            ),
                                            str("subnet-router-anycast")
                                        )
                                    ),
                                    a(str("demux-source"), arg | arg | arg),
                                    a(str("demux-destination"), arg | arg),
                                    b(str("unnumbered-address"),
                                        sc(
                                              interface_unit,
                                            b(str("preferred-source-address"),
                                              (arg | arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    str("dad-disable"),
                                    str("no-dad-disable"),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    a(str("mtu"), arg),
                                    a(str("maximum-labels"), arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              a(str("input"), arg),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("output-chain"), arg),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("mlppp"),
                                c(
                                    b(str("bundle"),
                                      (arg | arg)
                                    ),
                                    c(
                                      b(str("service-interface"),
                                        interface_device
                                      ),
                                      a(str("service-device-pool"), arg)
                                    ),
                                    a(str("dynamic-profile"), arg)
                                )
                            ),
                            b(str("mlfr-end-to-end"),
                                c(
                                    b(str("bundle"),
                                      interface_unit
                                    )
                                )
                            ),
                            b(str("mlfr-uni-nni"),
                                c(
                                    b(str("bundle"),
                                      interface_unit
                                    )
                                )
                            ),
                            b(str("ccc"),
                                c(
                                    a(str("mtu"), arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              a(str("input"), arg),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("output-chain"), arg),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    str("translate-fecn-and-becn"),
                                    c(
                                      str("translate-discard-eligible"),
                                      str("translate-plp-control-word-de")
                                    ),
                                    str("keep-address-and-control")
                                )
                            ),
                            b(str("tcc"),
                                c(
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("proxy"),
                                        c(
                                            b(str("inet-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("remote"),
                                        c(
                                            b(str("inet-address"),
                                              ipv4addr
                                            ),
                                            b(str("mac-address"),
                                              mac_addr
                                            )
                                        )
                                    ),
                                    b(str("protocols"),
                                      (str("mpls") | str("inet") | str("iso"))
                                    )
                                )
                            ),
                            b(str("vpls"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("interface-mode"),
                                      (str("access") | str("trunk"))
                                    ),
                                    str("vlan-auto-sense"),
                                    b(str("bridge-domain-type"),
                                      (str("svlan") | str("bvlan"))
                                    ),
                                    str("inter-switch-link"),
                                    c(
                                      a(str("vlan-id"), arg),
                                      a(str("vlan-id-list"), arg),
                                      a(str("inner-vlan-id-list"), arg)
                                    ),
                                    b(str("vlan-rewrite"),
                                        c(
                                            b(a(str("translate"), arg),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    c(
                                      b(str("isid-list"),
                                        (str("all-service-groups") | str("all"))
                                      )
                                    ),
                                    b(str("storm-control"),
                                        c(
                                            arg
                                        )
                                    ),
                                    b(str("recovery-timeout"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    )
                                )
                            ),
                            b(str("ethernet-switching"),
                              ethernet_switching_type
                            ),
                            b(str("fibre-channel"),
                              fibre_channel_type
                            ),
                            b(str("pppoe"),
                              pppoe_underlying_options_type
                            ),
                            b(str("any"),
                                c(
                                    b(str("filter"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("group"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("service-domain"),
                      (str("inside") | str("outside"))
                    ),
                    str("copy-tos-to-outer-ip-header"),
                    str("copy-tos-to-outer-ip-header-transit"),
                    str("force-control-packets-on-transit-path"),
                    b(str("load-balancing-options"),
                        c(
                            b(str("preferred-active"),
                              interface_device
                            ),
                            str("disable-hash"),
                            b(str("hash-keys"),
                                c(
                                    b(str("ingress-key"),
                                          enum((str("source-ip") | str("destination-ip") | str("protocol") | str("iif")))
                                    ),
                                    b(str("egress-key"),
                                          enum((str("source-ip") | str("destination-ip") | str("protocol") | str("oif")))
                                    ),
                                    b(str("ipv6-source-prefix-length"),
                                      (str("56") | str("64") | str("96") | str("128"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("mac"),
                      mac_unicast
                    ),
                    b(str("virtual-gateway-v4-mac"),
                      mac_unicast
                    ),
                    b(str("virtual-gateway-v6-mac"),
                      mac_unicast
                    ),
                    b(str("forwarding-options"),
                        c(
                            b(str("load-balance-stateful"),
                                c(
                                    str("per-flow"),
                                    a(str("rebalance"), arg),
                                    b(str("load-type"),
                                      (str("high") | str("medium") | str("low"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("etree-ac-role"),
                      (str("root") | str("leaf"))
                    )
                )
            ),
            b(str("no-partition"),
                sc(
                    b(str("interface-type"),
                      (str("e1") | str("t1") | str("at") | str("t3") | str("e3") | str("ct3") | str("so") | str("cau4"))
                    )
                )
            ).as(:oneline),
            b(a(str("partition"), arg),
                sc(
                    a(str("oc-slice"), arg),
                    a(str("timeslots"), arg),
                    b(str("interface-type"),
                      (str("ds") | str("e1") | str("t1") | str("at") | str("ct1") | str("ce1") | str("t3") | str("ct3") | str("e3") | str("so") | str("coc1") | str("cau4") | str("dc") | str("bc"))
                    )
                )
            ).as(:oneline),
            b(str("radius-options"),
              radius_options_vlan_type
            )
        )
      )
    end

    rule(:ipr_profile_object) do
      b(arg.as(:arg),
        c(
            a(str("timeout"), arg),
            a(str("max-reassembly-pending-packets"), arg)
        )
      )
    end

    rule(:ipr_rule_object) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("input"))
            )
        )
      )
    end

    rule(:ipsec_services_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("timer") | str("routing-socket") | str("parse") | str("ike") | str("policy-manager") | str("general") | str("database") | str("certificates") | str("snmp") | str("ams") | str("lic") | str("all"))).as(:oneline)
        )
    end

    rule(:ipsec_vpn_rule_object) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      ipsec_vpn_match_object
                    ),
                    b(str("then"),
                        c(
                            str("syslog"),
                            b(str("remote-gateway"),
                              ipaddr
                            ),
                            b(str("backup-remote-gateway"),
                              ipaddr
                            ),
                            c(
                              b(str("manual"),
                                  c(
                                      a(str("direction"), enum(str("inbound") | str("outbound") | str("bidirectional")),
                                          c(
                                              b(str("protocol"),
                                                (str("ah") | str("esp") | str("bundle"))
                                              ),
                                              a(str("spi"), arg),
                                              a(str("auxiliary-spi"), arg),
                                              b(str("authentication"),
                                                  c(
                                                      b(str("algorithm"),
                                                        (str("hmac-md5-96") | str("hmac-sha1-96") | str("hmac-sha2-256") | str("hmac-sha-256-128"))
                                                      ),
                                                      b(str("key"),
                                                          sc(
                                                              c(
                                                                a(str("ascii-text"), arg),
                                                                a(str("hexadecimal"), arg)
                                                              )
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              ),
                                              b(str("encryption"),
                                                  c(
                                                      b(str("algorithm"),
                                                        (str("des-cbc") | str("3des-cbc") | str("aes-128-cbc") | str("aes-192-cbc") | str("aes-256-cbc"))
                                                      ),
                                                      b(str("key"),
                                                          sc(
                                                              c(
                                                                a(str("ascii-text"), arg),
                                                                a(str("hexadecimal"), arg)
                                                              )
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("dynamic"),
                                  c(
                                      a(str("ike-policy"), arg),
                                      a(str("ipsec-policy"), arg),
                                      a(str("natt-install-interval"), arg)
                                  )
                              )
                            ),
                            str("clear-dont-fragment-bit"),
                            str("copy-dont-fragment-bit"),
                            str("set-dont-fragment-bit"),
                            str("no-anti-replay"),
                            a(str("tunnel-mtu"), arg),
                            str("copy-ttl-from-inner-ip-header"),
                            a(str("ttl"), arg),
                            str("copy-tos-from-inner-ip-header"),
                            a(str("tos"), arg),
                            str("initiate-dead-peer-detection"),
                            b(str("dead-peer-detection"),
                                c(
                                    a(str("interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            a(str("anti-replay-window-size"), arg)
                        )
                    )
                )
            ),
            b(str("match-direction"),
              (str("input") | str("output"))
            )
        )
      )
    end

    rule(:ipsec_vpn_match_object) do
        c(
            b(str("source-address"),
              ipsec_vpn_addr_object
            ),
            b(str("destination-address"),
              ipsec_vpn_addr_object
            ),
            b(str("ipsec-inside-interface"),
              interface_unit
            )
        )
    end

    rule(:ipsec_vpn_addr_object) do
      arg.as(:arg).as(:oneline)
    end

    rule(:jsrc_options) do
        c(
            b(a(str("partition"), arg),
                c(
                    a(str("diameter-instance"), arg),
                    a(str("destination-realm"), arg),
                    a(str("destination-host"), arg)
                )
            )
        )
    end

    rule(:juniper_access_options) do
        c(
            b(str("radius-server"),
              access_radius_server_object
            ),
            a(str("radius-disconnect-port"), arg),
            b(str("radius-disconnect"),
              radius_disconnect_object
            ),
            a(str("domain-name-server"), arg),
            a(str("domain-name-server-inet"), arg),
            a(str("domain-name-server-inet6"), arg),
            a(str("wins-server"), arg),
            b(str("address-pool"),
              address_pool_object
            ),
            b(str("group-profile"),
              group_profile_object
            ),
            b(a(str("profile"), arg),
                c(
                    b(str("accounting-order"),
                      (str("radius"))
                    ),
                    b(str("authentication-order"),
                      (str("radius") | str("password") | str("none") | str("nasreq") | str("ldap") | str("securid") | str("s6a"))
                    ),
                    b(str("authorization-order"),
                      (str("jsrc") | str("nasreq") | str("none"))
                    ),
                    b(str("provisioning-order"),
                      (str("jsrc") | str("gx-plus") | str("pcrf"))
                    ),
                    b(str("preauthentication-order"),
                      (str("radius"))
                    ),
                    b(str("charging-service-list"),
                      (str("ocs"))
                    ),
                    a(str("domain-name-server"), arg),
                    a(str("domain-name-server-inet"), arg),
                    a(str("domain-name-server-inet6"), arg),
                    a(str("wins-server"), arg),
                    b(str("client"),
                      access_client_object
                    ),
                    b(str("address-assignment"),
                        c(
                            a(str("pool"), arg)
                        )
                    ),
                    a(str("session-limit-per-username"), arg),
                    b(str("local"),
                        c(
                            a(str("flat-file-profile"), arg)
                        )
                    ),
                    b(str("radius"),
                        c(
                            b(str("authentication-server"),
                              ipaddr
                            ),
                            b(str("accounting-server"),
                              ipaddr
                            ),
                            b(str("preauthentication-server"),
                              ipv4addr
                            ),
                            b(str("options"),
                                c(
                                    str("ethernet-port-type-virtual"),
                                    b(str("interface-description-format"),
                                        c(
                                            str("exclude-sub-interface"),
                                            str("exclude-adapter"),
                                            str("exclude-channel")
                                        )
                                    ),
                                    a(str("nas-identifier"), arg),
                                    b(str("nas-port-extended-format"),
                                        c(
                                            a(str("ae-width"), arg),
                                            a(str("slot-width"), arg),
                                            a(str("adapter-width"), arg),
                                            a(str("port-width"), arg),
                                            a(str("pw-width"), arg),
                                            a(str("stacked-vlan-width"), arg),
                                            a(str("vlan-width"), arg),
                                            b(str("atm"),
                                                c(
                                                    a(str("slot-width"), arg),
                                                    a(str("adapter-width"), arg),
                                                    a(str("port-width"), arg),
                                                    a(str("vpi-width"), arg),
                                                    a(str("vci-width"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    a(str("nas-port-id-delimiter"), arg),
                                    b(str("nas-port-id-format"),
                                        c(
                                            str("nas-identifier"),
                                            str("interface-description"),
                                            str("agent-circuit-id"),
                                            str("agent-remote-id"),
                                            str("postpend-vlan-tags"),
                                            str("interface-text-description"),
                                            b(str("order"),
                                              (str("nas-identifier") | str("agent-circuit-id") | str("agent-remote-id") | str("interface-description") | str("interface-text-description") | str("postpend-vlan-tags"))
                                            )
                                        )
                                    ),
                                    b(str("nas-port-type"),
                                        c(
                                            b(str("ethernet"),
                                              (str("async") | str("sync") | str("isdn-sync") | str("isdn-v120") | str("isdn-v110") | str("virtual") | str("piafs") | str("hdlc-clear-channel") | str("x25") | str("x75") | str("g3-fax") | str("sdsl") | str("adsl-cap") | str("adsl-dmt") | str("idsl") | str("ethernet") | str("xdsl") | str("cable") | str("wireless") | str("wireless-ieee80211") | str("token-ring") | str("fddi") | str("wireless-cdma2000") | str("wireless-umts") | str("wireless-1x-ev") | str("iapp") | arg)
                                            )
                                        )
                                    ),
                                    a(str("calling-station-id-delimiter"), arg),
                                    b(str("calling-station-id-format"),
                                        c(
                                            str("nas-identifier"),
                                            str("interface-description"),
                                            str("agent-circuit-id"),
                                            str("agent-remote-id"),
                                            str("mac-address"),
                                            str("interface-text-description"),
                                            str("stacked-vlan"),
                                            str("vlan")
                                        )
                                    ),
                                    a(str("remote-circuit-id-delimiter"), arg),
                                    b(str("remote-circuit-id-format"),
                                        c(
                                            str("agent-circuit-id"),
                                            str("agent-remote-id")
                                        )
                                    ),
                                    b(str("remote-circuit-id-fallback"),
                                      (str("default") | str("configured-calling-station-id"))
                                    ),
                                    b(str("override"),
                                        c(
                                            b(str("calling-station-id"),
                                                sc(
                                                    str("remote-circuit-id")
                                                )
                                            ).as(:oneline),
                                            b(str("nas-port"),
                                              (str("tunnel-client-nas-port"))
                                            ),
                                            b(str("nas-port-type"),
                                              (str("tunnel-client-nas-port-type"))
                                            ),
                                            b(str("nas-ip-address"),
                                              (str("tunnel-client-gateway-address"))
                                            )
                                        )
                                    ),
                                    b(str("accounting-session-id-format"),
                                      (str("decimal") | str("description"))
                                    ),
                                    a(str("revert-interval"), arg),
                                    str("vlan-nas-port-stacked-format"),
                                    b(str("client-authentication-algorithm"),
                                      (str("direct") | str("round-robin"))
                                    ),
                                    b(str("client-accounting-algorithm"),
                                      (str("direct") | str("round-robin"))
                                    ),
                                    str("juniper-access-line-attributes"),
                                    b(str("ip-address-change-notify"),
                                        sc(
                                            a(str("message"), quote | arg)
                                        )
                                    ).as(:oneline),
                                    str("coa-dynamic-variable-validation"),
                                    str("chap-challenge-in-request-authenticator"),
                                    b(str("service-activation"),
                                        c(
                                            b(str("extensible-service"),
                                              (str("required-at-login") | str("optional-at-login"))
                                            ),
                                            b(str("dynamic-profile"),
                                              (str("required-at-login") | str("optional-at-login"))
                                            )
                                        )
                                    ),
                                    str("accounting-username-original")
                                )
                            ),
                            b(str("attributes"),
                                c(
                                    b(str("ignore"),
                                        c(
                                            str("output-filter"),
                                            str("input-filter"),
                                            str("framed-ip-netmask"),
                                            str("logical-system-routing-instance"),
                                            str("dynamic-iflset-name"),
                                            str("idle-timeout"),
                                            str("session-timeout"),
                                            a(str("standard-attribute"), arg),
                                            b(a(str("vendor-id"), arg),
                                                c(
                                                    a(str("vendor-attribute"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("exclude"),
                                        c(
                                            b(a(str("standard-attribute"), arg),
                                                c(
                                                    b(str("packet-type"),
                                                      (str("access-request") | str("accounting-on") | str("accounting-off") | str("accounting-start") | str("accounting-stop"))
                                                    )
                                                )
                                            ),
                                            b(a(str("vendor-id"), arg),
                                                c(
                                                    b(a(str("vendor-attribute"), arg),
                                                        c(
                                                            b(str("packet-type"),
                                                              (str("access-request") | str("accounting-on") | str("accounting-off") | str("accounting-start") | str("accounting-stop"))
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("accounting-authentic"),
                                              (str("accounting-on") | str("accounting-off") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("accounting-delay-time"),
                                              (str("accounting-on") | str("accounting-off") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("accounting-session-id"),
                                              (str("access-request"))
                                            ),
                                            b(str("accounting-terminate-cause"),
                                              (str("accounting-off"))
                                            ),
                                            b(str("called-station-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("calling-station-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("class"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("delegated-ipv6-prefix"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("dhcp-options"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("dhcp-gi-address"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("dhcp-mac-address"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("output-filter"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("event-time-stamp"),
                                              (str("accounting-on") | str("accounting-off") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("filter-id"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-ip-address"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-ip-netmask"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-ip-route"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-ipv6-address"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-ipv6-pool"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-ipv6-prefix"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-ipv6-route"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-pool"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("input-filter"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("input-gigapackets"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("input-gigawords"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("input-ipv6-packets"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("input-ipv6-gigawords"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("input-ipv6-octets"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("interface-description"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("nas-identifier"),
                                              (str("access-request") | str("accounting-on") | str("accounting-off") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("nas-port"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("nas-port-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("nas-port-type"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("output-gigapackets"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("output-gigawords"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("output-ipv6-packets"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("output-ipv6-gigawords"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("output-ipv6-octets"),
                                              (str("accounting-stop"))
                                            ),
                                            b(str("dynamic-iflset-name"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("dsl-forum-attributes"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("l2c-upstream-data"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("l2c-downstream-data"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("acc-loop-cir-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("acc-aggr-cir-id-bin"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("acc-aggr-cir-id-asc"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("act-data-rate-up"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("act-data-rate-dn"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("min-data-rate-up"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("min-data-rate-dn"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("att-data-rate-up"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("att-data-rate-dn"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("max-data-rate-up"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("max-data-rate-dn"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("min-lp-data-rate-up"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("min-lp-data-rate-dn"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("max-interlv-delay-up"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("act-interlv-delay-up"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("max-interlv-delay-dn"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("act-interlv-delay-dn"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("dsl-line-state"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("dsl-type"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("downstream-calculated-qos-rate"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("upstream-calculated-qos-rate"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("cos-shaping-rate"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("framed-interface-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("chargeable-user-identity"),
                                              (str("access-request"))
                                            ),
                                            b(str("l2tp-tx-connect-speed"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("l2tp-rx-connect-speed"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("tunnel-type"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("tunnel-medium-type"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("tunnel-client-endpoint"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("tunnel-server-endpoint"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("tunnel-assignment-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("tunnel-client-auth-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("tunnel-server-auth-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("acct-tunnel-connection"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("acc-loop-remote-id"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("acc-loop-encap"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("pppoe-description"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("virtual-router"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("first-relay-ipv4-address"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("first-relay-ipv6-address"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("dhcpv6-options"),
                                              (str("access-request") | str("accounting-start") | str("accounting-stop"))
                                            ),
                                            b(str("dhcp-header"),
                                              (str("access-request"))
                                            ),
                                            b(str("dhcpv6-header"),
                                              (str("access-request"))
                                            ),
                                            b(str("acct-request-reason"),
                                              (str("accounting-start") | str("accounting-stop"))
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("session-options"),
                        c(
                            a(str("client-group"), arg),
                            a(str("client-idle-timeout"), arg),
                            str("client-idle-timeout-ingress-only"),
                            a(str("client-session-timeout"), arg),
                            b(str("strip-user-name"),
                                c(
                                    b(str("delimiter"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline),
                                    b(str("parse-direction"),
                                        sc(
                                            c(
                                              str("right-to-left"),
                                              str("left-to-right")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("pcc-context"),
                                c(
                                    a(str("pcef-profile"), arg),
                                    a(str("input-service-set"), arg),
                                    a(str("output-service-set"), arg),
                                    a(str("input-ipv6-service-set"), arg),
                                    a(str("output-ipv6-service-set"), arg),
                                    a(str("input-service-filter"), arg),
                                    a(str("output-service-filter"), arg),
                                    a(str("input-ipv6-service-filter"), arg),
                                    a(str("output-ipv6-service-filter"), arg)
                                )
                            )
                        )
                    ),
                    b(str("client-name-filter"),
                      access_client_name_filter_object
                    ),
                    b(str("ldap-options"),
                      access_ldap_options
                    ),
                    b(str("ldap-server"),
                      ldap_server_object
                    ),
                    b(str("radius-server"),
                      profile_radius_server_object
                    ),
                    b(str("radius-options"),
                      access_radius_options
                    ),
                    b(str("accounting"),
                        c(
                            b(str("order"),
                              (str("radius"))
                            ),
                            str("accounting-stop-on-failure"),
                            str("accounting-stop-on-access-deny"),
                            str("immediate-update"),
                            str("coa-immediate-update"),
                            str("address-change-immediate-update"),
                            a(str("update-interval"), arg),
                            b(str("statistics"),
                              (str("volume-time") | str("time"))
                            ),
                            str("wait-for-acct-on-ack"),
                            str("send-acct-status-on-config-change"),
                            str("duplication"),
                            b(str("duplication-filter"),
                              (str("interim-original") | str("interim-duplicated") | str("exclude-attributes"))
                            ),
                            b(str("duplication-vrf"),
                                c(
                                    a(str("vrf-name"), arg),
                                    a(str("access-profile-name"), arg)
                                )
                            ),
                            b(str("duplication-attribute-format"),
                              (str("username"))
                            ),
                            str("ancp-speed-change-immediate-update"),
                            str("family-state-change-immediate-update")
                        )
                    ),
                    b(str("service"),
                        c(
                            b(str("accounting-order"),
                              (str("activation-protocol") | str("radius") | str("local"))
                            ),
                            b(str("accounting"),
                                c(
                                    a(str("update-interval"), arg),
                                    b(str("statistics"),
                                      (str("time") | str("volume-time"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("jsrc"),
                        c(
                            b(str("attributes"),
                                c(
                                    b(str("exclude"),
                                        c(
                                            b(str("user-name"),
                                              (str("authorization-request") | str("provisioning-request"))
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("subscriber"),
                      localauth_subscriber_object
                    )
                )
            ),
            b(str("address-assignment"),
              address_assignment_type
            ),
            b(str("address-protection"),
                c(
                    str("reassign-on-match")
                )
            ),
            b(str("address-preservation"),
                c(
                    b(str("address-types"),
                      (str("delegated-prefix"))
                    ),
                    a(str("aging-time"), arg)
                )
            ),
            str("linked-pool-aggregation"),
            b(a(str("tunnel-profile"), arg),
                c(
                    b(a(str("tunnel"), arg),
                        c(
                            a(str("preference"), arg),
                            b(str("remote-gateway"),
                                c(
                                    b(str("address"),
                                      ipv4addr
                                    ),
                                    a(str("gateway-name"), arg)
                                )
                            ),
                            b(str("source-gateway"),
                                c(
                                    b(str("address"),
                                      ipv4addr
                                    ),
                                    a(str("gateway-name"), arg)
                                )
                            ),
                            c(
                              a(str("routing-instance"), arg),
                              b(a(str("logical-system"), arg),
                                  c(
                                      a(str("routing-instance"), arg)
                                  )
                              )
                            ),
                            a(str("secret"), arg),
                            b(str("medium"),
                              (str("ipv4"))
                            ),
                            b(str("tunnel-type"),
                              (str("l2tp"))
                            ),
                            a(str("identification"), arg),
                            a(str("max-sessions"), arg),
                            b(str("nas-port-method"),
                              (str("cisco-avp"))
                            )
                        )
                    )
                )
            ),
            b(a(str("tunnel-switch-profile"), arg),
                c(
                    b(str("avp"),
                        c(
                            b(str("calling-number"),
                              (str("regenerate") | str("relay") | str("drop"))
                            ),
                            b(str("bearer-type"),
                              (str("regenerate") | str("relay") | str("drop"))
                            ),
                            b(str("cisco-nas-port-info"),
                              (str("regenerate") | str("relay") | str("drop"))
                            )
                        )
                    ),
                    a(str("tunnel-profile"), arg)
                )
            ),
            b(str("domain"),
              domain_map_type
            ),
            b(str("ppp-options"),
                c(
                    b(str("compliance"),
                        c(
                            b(str("rfc"),
                              (str("2486"))
                            )
                        )
                    )
                )
            ),
            b(str("gx-plus"),
              gx_plus_definition
            ),
            b(str("pcrf"),
              pcrf_definition
            ),
            b(str("ocs"),
              ocs_definition
            ),
            b(str("radsec"),
              radsec_definition
            ),
            b(str("s6a"),
              s6a_definition
            ),
            str("report-interface-descriptions"),
            b(str("nasreq"),
              nasreq_definition
            ),
            b(str("protocol-attributes"),
              protocol_attribute_type
            ),
            b(a(str("aaa-options"), arg),
                c(
                    a(str("access-profile"), arg),
                    a(str("aaa-context"), arg),
                    a(str("subscriber-context"), arg)
                )
            ),
            b(str("radius-options"),
              access_radius_options
            ),
            b(str("ldap-options"),
              access_ldap_options
            ),
            b(str("ldap-server"),
              ldap_server_object
            ),
            b(str("securid-server"),
              securid_server_object
            ),
            b(str("accounting-backup-options"),
                c(
                    a(str("max-pending-accounting-stops"), arg),
                    a(str("max-withhold-time"), arg)
                )
            ),
            b(str("terminate-code"),
                c(
                    b(str("aaa"),
                        c(
                            b(str("deny"),
                                c(
                                    b(str("authentication-denied"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-resources"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("server-request-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("service-shutdown"),
                                c(
                                    b(str("network-logout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("remote-reset"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("subscriber-logout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("time-limit"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("volume-limit"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("shutdown"),
                                c(
                                    b(str("administrative-reset"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("idle-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("reassign-on-match"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("remote-reset"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("session-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("dhcp"),
                        c(
                            b(str("client-request"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("lost-carrier"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("nak"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("nas-logout"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-offers"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("hybrid-access"),
                        c(
                            b(str("admin-down"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("client-request"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("lost-carrier"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("nak"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("nas-logout"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-resource"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("l2tp"),
                        c(
                            b(str("issu"),
                                c(
                                    b(str("in-progress"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("session"),
                                c(
                                    b(str("access-interface-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("administrative-close"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("administrative-drain"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("call-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("call-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("create-failed"),
                                        c(
                                            b(str("icrq-to-initiator-tunnel"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("invalid-config"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("limit-reached"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("single-shot-tunnel-already-fired"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("too-busy"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("failover-protocol-resync-disconnect"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("hardware-unavailable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-resources-server-port"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("not-ready"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("receive-cdn"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-result-code"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-iccn"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-framing-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-proxy-authen-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-unsupported-proxy-authen-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-connect-speed"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-framing-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-proxy-authen-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-proxy-authen-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-proxy-authen-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-proxy-authen-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-icrp"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-icrq"),
                                        c(
                                            b(str("administrative-close"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("authenticate-failed-host"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-bearer-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-cisco-nas-port"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-call-serial-number"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-occn"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-framing-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-connect-speed"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-framing-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-ocrp"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-ocrq"),
                                        c(
                                            b(str("administrative-close"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("authenticate-failed-host"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-bearer-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-framing-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-bearer-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-call-serial-number"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-called-number"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-framing-type"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-maximum-bps"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-minimum-bps"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unsupported"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-sli"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-accm"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-accm"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-unexpected-packet"),
                                        c(
                                            b(str("lac-incoming"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("lac-outgoing"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("lns-incoming"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("lns-outgoing"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-unknown-session-id"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("receive-wen"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-call-errors"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("timeout-connection"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("timeout-inactivity"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("timeout-session"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("timeout-upper-create"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("transmit-speed-unavailable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("tunnel-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("tunnel-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("tunnel-switch-profile-deleted"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("tunneled-interface-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("unknown-cause"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("upper-create-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("upper-removed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("warmstart-not-operational"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("warmstart-recovery-error"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("warmstart-uppper-not-restacked"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("session-eracheck-failed"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("session-mappedswitchedsession-down"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("session-rx-csurq-avp-unknown"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("session-rx-icrq-issu-in-progress"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("session-rx-ocrq-issu-in-progress"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("session-sdb-release"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("session-stray-ifl-association"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("session-tunnelswitch-error"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("session-uptimer-expiry"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("tunnel"),
                                c(
                                    b(str("administrative-close"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("administrative-drain"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("control-channel-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("created-no-sessions"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("destination-address-changed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("destination-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failover-protocol"),
                                        c(
                                            b(str("no-resources-for-recovery-tunnel"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources-for-session-resync"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("not-supported"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("not-supported-by-peer"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("recovery-control-channel-failed"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("recovery-tunnel-failed"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("recovery-tunnel-finished"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("recovery-tunnel-primary-down"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-resync-failed"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("host-profile-changed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("host-profile-deleted"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("receive-fsq"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-failover-session-state"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-fsr"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-failover-session-state"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-recovery-scccn"),
                                        c(
                                            b(str("authenticate-failed-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unexpected-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-recovery-scccp"),
                                        c(
                                            b(str("avp-unexpected-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-recovery-scccp-avp-bad-value-challenge-response"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("receive-recovery-scccp-avp-missing-challenge-response"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("receive-recovery-sccrp"),
                                        c(
                                            b(str("authenticate-failed-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-bearer-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-framing-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-protocol-version"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-receive-window-size"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-suggested-control-sequence"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-mismatched-host-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-mismatched-vendor-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-framing-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-host-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-protocol-version"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unexpected-challenge-without-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-recovery-sccrq"),
                                        c(
                                            b(str("administrative-close"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-bearer-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-framing-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-protocol-version"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-receive-window-size"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-tunnel"),
                                                c(
                                                    b(str("recovery"),
                                                        c(
                                                            b(str("radius"),
                                                                sc(
                                                                      arg
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-tie-breaker"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-mismatched-host-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-mismatched-vendor-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-framing-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-host-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-protocol-version"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-tunnel"),
                                                c(
                                                    b(str("recovery"),
                                                        c(
                                                            b(str("radius"),
                                                                sc(
                                                                      arg
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-tie-breaker"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unexpected-challenge-without-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources-max-tunnels"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("tunnel-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-recovery-stopccn"),
                                        c(
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-result-code"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-recovery-unexpected-packet"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("receive-recovery-unknown-packet"),
                                        c(
                                            b(str("message-type-indecipherable"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("message-type-unrecognized"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-scccn"),
                                        c(
                                            b(str("authenticate-failed-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unexpected-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-sccrp"),
                                        c(
                                            b(str("authenticate-failed-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("authenticate-failed-host"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-bearer-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-failover-capability"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-framing-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-protocol-version"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-receive-window-size"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-framing-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-host-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-protocol-version"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unexpected-challenge-response"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unexpected-challenge-without-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-sccrq"),
                                        c(
                                            b(str("administrative-close"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("authenticate-failed-host"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-bearer-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-challenge"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-failover-capability"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-framing-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-protocol-version"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-receive-window-size"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-framing-capabilities"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-host-name"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-protocol-version"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unexpected-challenge-without-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("bad-address"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("invalid-ns"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources-max-tunnels"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("unexpected"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-session-packet"),
                                        c(
                                            b(str("null-session-id-invalid"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("null-session-id-without-assigned-session-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-stopccn"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline),
                                            b(str("avp-bad-hidden"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-bad-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-duplicate-value-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-bad-length"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-malformed-truncated"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-assigned-tunnel-id"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-mandatory-result-code"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-random-vector"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-missing-secret"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("avp-unknown"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("no-resources"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("session-id-not-null"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-unexpected-packet"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline),
                                            b(str("for-session"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("receive-unknown-packet"),
                                        c(
                                            b(str("message-type-indecipherable"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("message-type-unrecognized"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("timeout-connection"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("timeout-connection-recovery-tunnel"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("timeout-idle"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("unknown-cause"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("warmstart-not-operational"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("warmstart-recovery-error"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("ppp"),
                        c(
                            b(str("admin-logout"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("admin-reconnect-request"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("authenticate"),
                                c(
                                    b(str("authenticator-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("challenge-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("chap-no-resources"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("chap-peer-authenticator-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("chap-peer-challenge-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("deny-by-peer"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("eap-challenge-larger-than-mtu"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("eap-peer-authenticator-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("eap-request-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("inactivity-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-requests"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-authenticator"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-resources"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("pap-peer-authenticator-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("pap-request-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("session-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("too-many-requests"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("tunnel-fail-immediate"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("tunnel-unsupported-tunnel-type"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("bridging"),
                                c(
                                    b(str("admin-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-activate-family-bridging"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("inhibited-by-authentication"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("link-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-configure-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-passive-retries-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-sevice-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-ieee802-tagged-frame-format"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-mac-frame-format"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-ieee802-tagged-frame-format"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-mac-fram-fromat"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-service"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("renegotiate-rx-conf-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("renegotiate-rx-conf-nak"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("renegotiate-rx-conf-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("renegotiate-rx-conf-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("stale-stacking"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("terminate-code-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("terminate-term-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("terminate-term-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("bundle"),
                                c(
                                    b(str("fail-activation"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-create"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-engine-add"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-fragment-size-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-fragmentation-location"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-fragmentation-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-hash-link-selection-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-join"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-local-mped-not-set-yet"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-local-mrru-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-local-mru-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-peer-endpoint-discriminator-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-peer-mrru-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-profile-nak"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-reassembly-location"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-reassembly-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-record-network"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-server-location-mismatch"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-static-link"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("fail-unrecoverable-ifl"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("dynamic-profile-instantiation-failed"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("failover-during-authentication"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("interface-admin-disable"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("interface-no-hardware"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("ip"),
                                c(
                                    b(str("admin-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-activate-family-inet"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-activate-services"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-add-access-internal-route"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("inhibited-by-authentication"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("link-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-configure-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-passive-retries-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-ip-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-ip-address-mask"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-primary-dns-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-primary-nbns-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-secondary-dns-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-secondary-nbns-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-ip-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-ip-address-mask"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-primary-dns-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-primary-nbns-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-secondary-dns-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-secondary-nbns-address"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-service"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-nak"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-code-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("service-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("stale-stacking"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("ipv6"),
                                c(
                                    b(str("admin-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-activate-family-inet6"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-activate-services"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("inhibited-by-authentication"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("link-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("local-and-peer-interface-ids-identical"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-configure-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-passive-retries-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-ipv6-interface-id"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-ipv6-interface-id"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-service"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-nak"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-code-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("service-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("stale-stacking"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("l2tp-session"),
                                c(
                                    b(str("apply-link-attribute-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("lcp"),
                                c(
                                    b(str("authenticate-terminate-hold"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("configured-mrru-too-small"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("configured-mru-invalid"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("configured-mru-too-small"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("dynamic-interface-hold"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-activate-services"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("keepalive-failure"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("loopback-rx-conf-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("loopback-rx-echo-reply"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("loopback-rx-echo-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-configure-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-passive-retries-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("mru-changed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("negotiation-timeout"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-accm"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-acfc"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-authentication"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-endpoint-discriminator"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-magic-number"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-mrru"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-mru"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-pfc"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-accm"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-acfc"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-authentication"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-endpoint-discriminator"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-magic-number"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-mrru"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-mru"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-pfc"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-nak"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-code-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-protocol-reject"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("tunnel-disconnected"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("tunnel-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("license-limit-exceeded"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("link-interface-no-hardware"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("lower-interface-attach-failed"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("lower-interface-down"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("lower-interface-teardown"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    b(str("admin-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-activate-family-mpls"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("link-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-configure-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-passive-retries-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-service"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-nak"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-code-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("service-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("stale-stacking"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("network-interface-admin-disable"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-bundle"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-interface"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-link-interface"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-ncps-available"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-network-interface"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-upper-interface"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("osi"),
                                c(
                                    b(str("admin-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("failed-to-activate-family-osi"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("link-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-configure-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("max-passive-retries-exceeded"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-local-align-npdu"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-peer-align-npdu"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-service"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-nak"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-renegotiate-rx-conf-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-code-rej"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-ack"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("peer-terminate-term-req"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("service-disable"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("stale-stacking"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("recovery"),
                                c(
                                    b(str("active-state-cleanup"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("configured-state-cleanup"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("init-state-cleanup"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("terminated-state-cleanup"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("terminating-state-cleanup"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("session-init-failed"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("subscriber-mgr"),
                                c(
                                    b(str("activation-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("get-credentials-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("link-interface-not-found"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("set-state-active-failed"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("vlan"),
                        c(
                            b(str("admin-logout"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("admin-reconnect"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("other"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("out-of-band"),
                                c(
                                    b(str("access-interface-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("admin-access-interface-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("admin-core-interface-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("ancp"),
                                        c(
                                            b(str("port-down"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("port-vlan-id-change"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("core-interface-down"),
                                        c(
                                            b(str("radius"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("l2-wholesale"),
                                        c(
                                            b(str("no-free-vlans"),
                                                c(
                                                    b(str("radius"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("profile-request-error"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("sdb-error"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("subscriber-activate-error"),
                                c(
                                    b(str("radius"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("diameter-profiles"),
              aaa_diameter_profiles
            ),
            b(str("radius"),
              juniper_radius
            ),
            b(str("diameter"),
              juniper_mobile_diameter
            )
        )
    end

    rule(:aaa_diameter_profiles) do
        c(
            b(str("gy-profile"),
              aaa_diameter_profile_type_gy
            ),
            b(str("gx-profile"),
              aaa_diameter_profile_type_gx
            )
        )
    end

    rule(:aaa_diameter_profile_type_gx) do
      b(arg.as(:arg),
        c(
            b(str("targets"),
              aaa_diameter_target
            ),
            a(str("request-timeout"), arg),
            b(str("attributes"),
              aaa_diameter_gx_profile_attr_type
            )
        )
      )
    end

    rule(:aaa_diameter_gx_profile_attr_type) do
        c(
            b(str("include"),
                c(
                    a(str("gx-capability-list"), arg),
                    a(str("rule-suggestion"), arg),
                    str("rai"),
                    str("qos-negotiation"),
                    str("qos-upgrade")
                )
            ),
            b(str("exclude"),
                c(
                    str("packet-filter-information"),
                    str("packet-filter-operation"),
                    str("rat-type"),
                    str("default-eps-bearer-qos"),
                    str("an-gw-address"),
                    str("network-request-support"),
                    str("event-trigger"),
                    str("threegpp-rat-type"),
                    str("offline"),
                    str("qos-negotiation"),
                    str("qos-upgrade")
                )
            )
        )
    end

    rule(:aaa_diameter_profile_type_gy) do
      b(arg.as(:arg),
        c(
            b(str("targets"),
              aaa_diameter_target
            ),
            a(str("request-timeout"), arg),
            b(str("attributes"),
              aaa_diameter_gy_profile_attr_type
            )
        )
      )
    end

    rule(:aaa_diameter_gy_profile_attr_type) do
        c(
            b(str("include"),
                c(
                    str("cumulative-used-service-unit"),
                    str("credit-instance-id"),
                    str("service-start-timestamp"),
                    str("mscc-qos-information"),
                    str("framed-ip-address"),
                    str("framed-ipv6-prefix"),
                    str("gprs-negotiated-qos")
                )
            ),
            b(str("exclude"),
                c(
                    str("ps-information"),
                    str("username"),
                    str("user-equipment-info"),
                    str("all-3gpp-avps"),
                    str("qos-information"),
                    str("pdn-connection-id"),
                    str("dynamic-address-flag"),
                    str("serving-node-type"),
                    str("cc-selection-mode"),
                    str("start-time"),
                    str("stop-time"),
                    str("user-location-information")
                )
            )
        )
    end

    rule(:aaa_diameter_target) do
      b(arg.as(:arg),
        c(
            a(str("destination-realm"), arg),
            a(str("destination-host"), arg),
            a(str("priority"), arg),
            a(str("network-element"), arg)
        )
      )
    end

    rule(:access_client_name_filter_object) do
        c(
            a(str("domain-name"), arg),
            a(str("separator"), arg),
            a(str("count"), arg)
        )
    end

    rule(:access_client_object) do
      b(arg.as(:arg),
        c(
            str("no-rfc2486"),
            b(str("chap-secret"),
              unreadable
            ),
            b(str("pap-password"),
              unreadable
            ),
            c(
              b(str("ppp"),
                  c(
                      a(str("framed-pool"), arg),
                      a(str("idle-timeout"), arg),
                      b(str("ppp-options"),
                          c(
                              str("pap"),
                              str("chap")
                          )
                      ),
                      a(str("keepalive"), arg),
                      a(str("primary-dns"), arg),
                      a(str("secondary-dns"), arg),
                      a(str("primary-wins"), arg),
                      a(str("secondary-wins"), arg),
                      a(str("encapsulation-overhead"), arg),
                      str("cell-overhead"),
                      a(str("interface-id"), arg),
                      b(str("framed-ip-address"),
                        ipv4prefix
                      ),
                      a(str("keepalive-retries"), arg)
                  )
              ),
              b(str("l2tp"),
                  c(
                      a(str("maximum-sessions"), arg),
                      a(str("maximum-sessions-per-tunnel"), arg),
                      a(str("service-profile"), arg),
                      a(str("interface-id"), arg),
                      str("lcp-renegotiation"),
                      str("local-chap"),
                      b(str("override-result-code"),
                          c(
                              str("session-out-of-resource")
                          )
                      ),
                      a(str("aaa-access-profile"), arg),
                      b(str("multilink"),
                        multilink_object
                      ),
                      a(str("session-limit-group"), arg),
                      b(str("ppp-authentication"),
                        (str("chap") | str("pap"))
                      ),
                      a(str("shared-secret"), arg),
                      a(str("ppp-profile"), arg),
                      a(str("dynamic-profile"), arg)
                  )
              ),
              b(str("ike"),
                  c(
                      b(str("allowed-proxy-pair"),
                          s(
                            a(str("local"), arg),
                            a(str("remote"), arg)
                          )
                      ),
                      str("initiate-dead-peer-detection"),
                      b(str("dead-peer-detection"),
                          c(
                              a(str("interval"), arg),
                              a(str("threshold"), arg)
                          )
                      ),
                      b(str("respond-bad-spi"),
                          sc(
                                arg
                          )
                      ).as(:oneline),
                      c(
                        b(str("pre-shared-key"),
                            sc(
                                c(
                                  a(str("ascii-text"), arg),
                                  a(str("hexadecimal"), arg)
                                )
                            )
                        ).as(:oneline),
                        a(str("ike-policy"), arg)
                      ),
                      a(str("ipsec-policy"), arg),
                      b(str("reverse-route"),
                          c(
                              b(str("preference"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline)
                          )
                      ),
                      a(str("interface-id"), arg)
                  )
              )
            ),
            a(str("group-profile"), arg),
            a(str("user-group-profile"), arg),
            b(str("xauth"),
                c(
                    b(str("ip-address"),
                      ipv4prefix
                    )
                )
            ),
            a(str("client-group"), arg),
            b(str("firewall-user"),
                c(
                    a(str("password"), arg)
                )
            )
        )
      )
    end

    rule(:access_ldap_options) do
        c(
            a(str("revert-interval"), arg),
            a(str("base-distinguished-name"), arg),
            c(
              b(str("assemble"),
                  c(
                      a(str("common-name"), arg)
                  )
              ),
              b(str("search"),
                  c(
                      a(str("search-filter"), arg),
                      b(str("admin-search"),
                          c(
                              a(str("distinguished-name"), arg),
                              b(str("password"),
                                unreadable
                              )
                          )
                      )
                  )
              )
            )
        )
    end

    rule(:access_radius_options) do
        c(
            a(str("revert-interval"), arg),
            a(str("timeout-grace"), arg),
            a(str("request-rate"), arg),
            a(str("interim-rate"), arg),
            a(str("interim-update-tolerance"), arg),
            b(str("unique-nas-port"),
                c(
                    a(str("chassis-id"), arg),
                    a(str("chassis-id-width"), arg)
                )
            )
        )
    end

    rule(:access_radius_server_object) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("preauthentication-port"), arg),
            a(str("accounting-port"), arg),
            a(str("dynamic-request-port"), arg),
            b(str("secret"),
              unreadable
            ),
            b(str("preauthentication-secret"),
              unreadable
            ),
            a(str("timeout"), arg),
            a(str("retry"), arg),
            a(str("accounting-timeout"), arg),
            a(str("accounting-retry"), arg),
            a(str("max-outstanding-requests"), arg),
            b(str("source-address"),
              ipaddr
            ),
            a(str("routing-instance"), arg),
            a(str("radsec-destination"), arg)
        )
      )
    end

    rule(:address_assignment_type) do
        c(
            b(str("neighbor-discovery-router-advertisement"),
                sc(
                      arg
                )
            ).as(:oneline),
            a(str("high-utilization"), arg),
            a(str("abated-utilization"), arg),
            a(str("high-utilization-v6"), arg),
            a(str("abated-utilization-v6"), arg),
            b(a(str("dynamic-pool"), arg),
                c(
                    b(str("family"),
                        c(
                            b(str("inet6"),
                                c(
                                    a(str("delegated-prefix-length"), arg),
                                    b(str("from-interface"),
                                      interface_name
                                    ),
                                    b(a(str("range"), arg),
                                        c(
                                            b(str("masked-low"),
                                              ipv6prefix_mandatory
                                            ),
                                            b(str("masked-high"),
                                              ipv6prefix_mandatory
                                            ),
                                            a(str("prefix-length"), arg)
                                        )
                                    ),
                                    b(str("dhcp-attributes"),
                                      dynamic_dhcp_attribute_type
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("pool"), arg),
                c(
                    str("active-drain"),
                    str("hold-down"),
                    a(str("link"), arg),
                    b(str("family"),
                        c(
                            c(
                              b(str("inet"),
                                  c(
                                      b(str("network"),
                                        ipv4prefix
                                      ),
                                      b(a(str("range"), arg),
                                          c(
                                              b(str("low"),
                                                ipv4addr
                                              ),
                                              b(str("high"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      b(str("dhcp-attributes"),
                                        dhcp_attribute_type
                                      ),
                                      b(str("xauth-attributes"),
                                          c(
                                              b(str("primary-dns"),
                                                ipv4prefix
                                              ),
                                              b(str("secondary-dns"),
                                                ipv4prefix
                                              ),
                                              b(str("primary-wins"),
                                                ipv4prefix
                                              ),
                                              b(str("secondary-wins"),
                                                ipv4prefix
                                              )
                                          )
                                      ),
                                      b(a(str("host"), arg),
                                          c(
                                              b(str("hardware-address"),
                                                mac_addr
                                              ),
                                              b(str("ip-address"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      a(str("excluded-address"), arg),
                                      b(a(str("excluded-range"), arg),
                                          c(
                                              b(str("low"),
                                                ipv4addr
                                              ),
                                              b(str("high"),
                                                ipv4addr
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("inet6"),
                                  c(
                                      b(str("prefix"),
                                        ipv6prefix_mandatory
                                      ),
                                      b(a(str("range"), arg),
                                          c(
                                              b(str("low"),
                                                ipv6prefix_mandatory
                                              ),
                                              b(str("high"),
                                                ipv6prefix_mandatory
                                              ),
                                              a(str("prefix-length"), arg)
                                          )
                                      ),
                                      b(str("dhcp-attributes"),
                                        dhcp_attribute_type
                                      ),
                                      a(str("excluded-address"), arg),
                                      b(a(str("excluded-range"), arg),
                                          c(
                                              b(str("low"),
                                                ipv6addr
                                              ),
                                              b(str("high"),
                                                ipv6addr
                                              )
                                          )
                                      )
                                  )
                              )
                            )
                        )
                    )
                )
            ),
            b(a(str("location-pool"), arg),
                c(
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(a(str("location"), arg),
                                        c(
                                            b(str("address"),
                                              ipv4prefix
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("address-pools"),
              sm_ippool_pool
            )
        )
    end

    rule(:address_pool_object) do
      b(arg.as(:arg),
        c(
            c(
              b(str("address"),
                ipv4prefix
              ),
              b(str("address-range"),
                  sc(
                      b(str("low"),
                        ipv4addr
                      ),
                      b(str("high"),
                        ipv4addr
                      )
                  )
              ).as(:oneline)
            )
        )
      )
    end

    rule(:dhcp_attribute_type) do
        c(
            b(str("option-match"),
                c(
                    b(str("option-82"),
                        c(
                            b(a(str("circuit-id"), arg),
                                sc(
                                    a(str("range"), arg)
                                )
                            ).as(:oneline),
                            b(a(str("remote-id"), arg),
                                sc(
                                    a(str("range"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("maximum-lease-time"),
              (str("infinite") | arg)
            ),
            b(str("next-server"),
              ipv4addr
            ),
            b(str("server-identifier"),
              ipv4addr
            ),
            a(str("grace-period"), arg),
            a(str("domain-name"), arg),
            a(str("name-server"), arg),
            a(str("wins-server"), arg),
            a(str("router"), arg),
            a(str("boot-file"), arg),
            a(str("boot-server"), arg),
            b(str("tftp-server"),
              ipv4addr
            ),
            b(str("sip-server"),
                c(
                    a(str("name"), arg),
                    a(str("ip-address"), arg)
                )
            ),
            b(str("netbios-node-type"),
              (str("b-node") | str("p-node") | str("m-node") | str("h-node"))
            ),
            a(str("sip-server-domain-name"), arg),
            a(str("sip-server-address"), arg),
            a(str("dns-server"), arg),
            a(str("propagate-settings"), arg),
            b(str("propagate-ppp-settings"),
              interface_name
            ),
            b(a(str("option"), arg),
                sc(
                    c(
                      b(str("flag"),
                        (str("true") | str("false") | str("on") | str("off"))
                      ),
                      a(str("byte"), arg),
                      a(str("short"), arg),
                      a(str("unsigned-short"), arg),
                      a(str("integer"), arg),
                      a(str("unsigned-integer"), arg),
                      a(str("hex-string"), arg),
                      a(str("string"), arg),
                      b(str("ip-address"),
                        ipv4addr
                      ),
                      b(str("ipv6-address"),
                        ipv6addr
                      ),
                      b(str("array"),
                          c(
                              c(
                                b(str("flag"),
                                  (str("true") | str("false") | str("on") | str("off"))
                                ),
                                a(str("byte"), arg),
                                a(str("short"), arg),
                                a(str("unsigned-short"), arg),
                                a(str("integer"), arg),
                                a(str("unsigned-integer"), arg),
                                a(str("hex-string"), arg),
                                a(str("string"), arg),
                                b(str("ip-address"),
                                  ipv4addr
                                ),
                                b(str("ipv6-address"),
                                  ipv6addr
                                )
                              )
                          )
                      )
                    )
                )
            ).as(:oneline),
            b(str("valid-lifetime"),
              (str("infinite") | arg)
            ),
            b(str("preferred-lifetime"),
              (str("infinite") | arg)
            ),
            a(str("t1-percentage"), arg),
            a(str("t2-percentage"), arg),
            a(str("exclude-prefix-len"), arg),
            a(str("t1-renewal-time"), arg),
            a(str("t2-rebinding-time"), arg)
        )
    end

    rule(:domain_map_type) do
        c(
            b(a(str("map"), arg),
                c(
                    c(
                      b(str("aaa-routing-instance"),
                        (str("default") | arg)
                      ),
                      b(a(str("aaa-logical-system"), arg),
                          c(
                              b(str("aaa-routing-instance"),
                                (str("default") | arg)
                              )
                          )
                      )
                    ),
                    a(str("access-profile"), arg),
                    a(str("address-pool"), arg),
                    a(str("dynamic-profile"), arg),
                    a(str("override-password"), arg),
                    b(a(str("padn"), arg),
                        c(
                            b(str("mask"),
                              ipv4addr
                            ),
                            a(str("metric"), arg)
                        )
                    ),
                    c(
                      b(str("target-routing-instance"),
                        (str("default") | arg)
                      ),
                      b(a(str("target-logical-system"), arg),
                          c(
                              b(str("target-routing-instance"),
                                (str("default") | arg)
                              )
                          )
                      )
                    ),
                    str("strip-domain"),
                    b(str("strip-username"),
                        sc(
                            c(
                              str("right-to-left"),
                              str("left-to-right")
                            )
                        )
                    ).as(:oneline),
                    a(str("tunnel-profile"), arg),
                    a(str("tunnel-switch-profile"), arg)
                )
            ),
            b(str("parse-order"),
                sc(
                    c(
                      str("domain-first"),
                      str("realm-first")
                    )
                )
            ).as(:oneline),
            b(str("delimiter"),
                sc(
                      arg
                )
            ).as(:oneline),
            b(str("parse-direction"),
                sc(
                    c(
                      str("right-to-left"),
                      str("left-to-right")
                    )
                )
            ).as(:oneline),
            b(str("realm-delimiter"),
                sc(
                      arg
                )
            ).as(:oneline),
            b(str("realm-parse-direction"),
                sc(
                    c(
                      str("left-to-right"),
                      str("right-to-left")
                    )
                )
            ).as(:oneline)
        )
    end

    rule(:dynamic_dhcp_attribute_type) do
        c(
            b(str("maximum-lease-time"),
              (str("infinite") | arg)
            ),
            b(str("valid-lifetime"),
              (str("infinite") | arg)
            ),
            b(str("preferred-lifetime"),
              (str("infinite") | arg)
            ),
            a(str("dns-server"), arg),
            a(str("t1-percentage"), arg),
            a(str("t2-percentage"), arg)
        )
    end

    rule(:group_profile_object) do
      b(arg.as(:arg),
        c(
            b(str("ppp"),
                c(
                    a(str("framed-pool"), arg),
                    a(str("idle-timeout"), arg),
                    b(str("ppp-options"),
                        c(
                            str("pap"),
                            str("chap"),
                            a(str("mru"), arg),
                            b(str("mtu"),
                              (str("use-lower-layer") | arg)
                            ),
                            b(str("initiate-ncp"),
                                c(
                                    str("ip"),
                                    str("ipv6"),
                                    str("dual-stack-passive")
                                )
                            ),
                            str("peer-ip-address-optional"),
                            str("ipcp-suggest-dns-option"),
                            str("ignore-magic-number-mismatch"),
                            a(str("aaa-options"), arg)
                        )
                    ),
                    a(str("keepalive"), arg),
                    a(str("primary-dns"), arg),
                    a(str("secondary-dns"), arg),
                    a(str("primary-wins"), arg),
                    a(str("secondary-wins"), arg),
                    a(str("encapsulation-overhead"), arg),
                    str("cell-overhead"),
                    a(str("interface-id"), arg)
                )
            ),
            b(str("l2tp"),
                c(
                    a(str("maximum-sessions"), arg),
                    a(str("maximum-sessions-per-tunnel"), arg),
                    a(str("service-profile"), arg),
                    a(str("interface-id"), arg),
                    str("lcp-renegotiation"),
                    str("local-chap"),
                    b(str("override-result-code"),
                        c(
                            str("session-out-of-resource")
                        )
                    ),
                    b(str("multilink"),
                      multilink_object
                    )
                )
            )
        )
      )
    end

    rule(:gx_plus_definition) do
        c(
            b(a(str("partition"), arg),
                c(
                    a(str("diameter-instance"), arg),
                    a(str("destination-realm"), arg),
                    a(str("destination-host"), arg)
                )
            ),
            b(str("global"),
                c(
                    str("include-ipv6"),
                    a(str("max-outstanding-requests"), arg)
                )
            )
        )
    end

    rule(:juniper_bridge_domains) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("domain-type"),
              (str("bridge"))
            ),
            c(
              b(str("vlan-id"),
                (str("all") | str("none") | str("inner-all") | arg)
              ),
              b(str("vlan-tags"),
                  sc(
                      a(str("outer"), arg),
                      a(str("inner"), arg)
                  )
              ).as(:oneline),
              a(str("vlan-id-list"), arg)
            ),
            a(str("isid-list"), arg),
            str("vlan-id-scope-local"),
            a(str("service-id"), arg),
            a(str("domain-id"), arg),
            str("no-local-switching"),
            str("mcae-mac-synchronize"),
            str("mcae-mac-flush"),
            str("no-irb-layer-2-copy"),
            str("enable-mac-move-action"),
            a(str("interface"), arg | arg,
                c(
                    b(str("protect-interface"),
                      interface_name
                    )
                )
            ),
            b(str("routing-interface"),
              interface_unit
            ),
            b(str("forwarding-options"),
              juniper_bridge_forwarding_options
            ),
            b(str("multicast-snooping-options"),
              juniper_multicast_snooping_options
            ),
            b(str("bridge-options"),
              juniper_protocols_bd
            ),
            b(str("protocols"),
                c(
                    b(str("igmp-snooping"),
                      juniper_bd_protocols_igmp_snooping
                    ),
                    b(str("mld-snooping"),
                      juniper_bd_protocols_mld_snooping
                    )
                )
            ),
            b(str("vxlan"),
                c(
                    str("ovsdb-managed"),
                    a(str("vni"), arg),
                    b(str("multicast-group"),
                      ipv4addr
                    ),
                    str("encapsulate-inner-vlan"),
                    str("decapsulate-accept-inner-vlan"),
                    a(str("unreachable-vtep-aging-timer"), arg),
                    str("ingress-node-replication")
                )
            ),
            a(str("isolated-vlan"), arg),
            a(str("community-vlans"), arg),
            b(str("proxy-mac"),
                c(
                    str("irb"),
                      mac_unicast
                )
            )
        )
      )
    end

    rule(:juniper_bd_protocols_igmp_snooping) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("query-interval"), arg),
            b(str("l2-querier"),
                c(
                    b(str("source-address"),
                      ipv4addr
                    )
                )
            ),
            a(str("query-response-interval"), arg),
            a(str("query-last-member-interval"), arg),
            a(str("robust-count"), arg),
            str("learn-pim-router"),
            str("immediate-leave"),
            b(str("proxy"),
                c(
                    b(str("source-address"),
                      ipv4addr
                    ),
                    str("irb")
                )
            ),
            str("evpn-ssm-reports-only"),
            b(a(str("interface"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave"),
                    str("host-only-interface"),
                    a(str("group-limit"), arg),
                    b(str("static"),
                        c(
                            b(a(str("group"), arg),
                                c(
                                    a(str("source"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("pseudowire-remote-address"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave")
                )
            ),
            b(a(str("vlan"), arg),
                c(
                    a(str("query-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    b(str("proxy"),
                        c(
                            b(str("source-address"),
                              ipv4addr
                            )
                        )
                    ),
                    str("evpn-ssm-reports-only"),
                    b(a(str("interface"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave"),
                            str("host-only-interface"),
                            a(str("group-limit"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            a(str("source"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("pseudowire-remote-address"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave")
                        )
                    ),
                    b(a(str("qualified-vlan"), arg),
                        c(
                            a(str("query-interval"), arg),
                            a(str("query-response-interval"), arg),
                            a(str("query-last-member-interval"), arg),
                            a(str("robust-count"), arg),
                            str("immediate-leave"),
                            b(str("proxy"),
                                c(
                                    b(str("source-address"),
                                      ipv4addr
                                    )
                                )
                            ),
                            str("evpn-ssm-reports-only"),
                            b(a(str("interface"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave"),
                                    str("host-only-interface"),
                                    a(str("group-limit"), arg),
                                    b(str("static"),
                                        c(
                                            b(a(str("group"), arg),
                                                c(
                                                    a(str("source"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("pseudowire-remote-address"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave")
                                )
                            )
                        )
                    ),
                    str("disable")
                )
            )
        )
    end

    rule(:juniper_bd_protocols_mld_snooping) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("query-interval"), arg),
            b(str("l2-querier"),
                c(
                    b(str("source-address"),
                      ipv6addr
                    )
                )
            ),
            a(str("query-response-interval"), arg),
            a(str("query-last-member-interval"), arg),
            a(str("robust-count"), arg),
            str("immediate-leave"),
            b(str("proxy"),
                c(
                    b(str("source-address"),
                      ipv6addr
                    ),
                    str("irb")
                )
            ),
            str("evpn-ssm-reports-only"),
            b(a(str("interface"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave"),
                    str("host-only-interface"),
                    a(str("group-limit"), arg),
                    b(str("static"),
                        c(
                            b(a(str("group"), arg),
                                c(
                                    a(str("source"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("pseudowire-remote-address"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave")
                )
            ),
            b(a(str("vlan"), arg),
                c(
                    a(str("query-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    b(str("proxy"),
                        c(
                            b(str("source-address"),
                              ipv6addr
                            )
                        )
                    ),
                    str("evpn-ssm-reports-only"),
                    b(a(str("interface"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave"),
                            str("host-only-interface"),
                            a(str("group-limit"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            a(str("source"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("pseudowire-remote-address"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave")
                        )
                    ),
                    b(a(str("qualified-vlan"), arg),
                        c(
                            a(str("query-interval"), arg),
                            a(str("query-response-interval"), arg),
                            a(str("query-last-member-interval"), arg),
                            a(str("robust-count"), arg),
                            str("immediate-leave"),
                            b(str("proxy"),
                                c(
                                    b(str("source-address"),
                                      ipv6addr
                                    )
                                )
                            ),
                            str("evpn-ssm-reports-only"),
                            b(a(str("interface"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave"),
                                    str("host-only-interface"),
                                    a(str("group-limit"), arg),
                                    b(str("static"),
                                        c(
                                            b(a(str("group"), arg),
                                                c(
                                                    a(str("source"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("pseudowire-remote-address"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave")
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_bridge_forwarding_options) do
        c(
            b(str("filter"),
                c(
                    a(str("input"), arg),
                    a(str("output"), arg)
                )
            ),
            b(str("flood"),
                c(
                    a(str("input"), arg)
                )
            ),
            b(str("dhcp-relay"),
              jdhcp_relay_type
            ),
            b(str("dhcp-security"),
              jdhcp_security_type
            )
        )
    end

    rule(:jdhcp_relay_type) do
        c(
            b(str("traceoptions"),
              jdhcp_traceoptions_type
            ),
            b(str("persistent-storage"),
                sc(
                    str("automatic")
                )
            ).as(:oneline),
            str("duplicate-clients-on-interface"),
            b(str("duplicate-clients-in-subnet"),
              jdhcp_duplicate_clients_in_subnet_type
            ).as(:oneline),
            b(str("interface-traceoptions"),
              jdhcp_interface_traceoptions_type
            ),
            b(str("dhcpv6"),
              dhcpv6_relay_type
            ),
            str("arp-inspection"),
            b(str("forward-snooped-clients"),
                sc(
                    c(
                      str("configured-interfaces"),
                      str("non-configured-interfaces"),
                      str("all-interfaces")
                    )
                )
            ).as(:oneline),
            b(str("authentication"),
              authentication_type
            ),
            b(str("liveness-detection"),
              dhcp_liveness_detection_type
            ),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline),
            b(str("overrides"),
              override_type
            ),
            b(str("relay-option"),
              dhcp_generic_v4_option
            ),
            b(str("server-match"),
                c(
                    b(str("default-action"),
                      server_match_action_choice
                    ),
                    b(a(str("address"), arg),
                        c(
                            c(
                              str("forward-only"),
                              str("create-relay-entry")
                            )
                        )
                    )
                )
            ),
            b(str("relay-option-60"),
              relay_option_60_type_top
            ),
            b(str("relay-option-82"),
              relay_option_82_type
            ),
            b(str("forward-only"),
              forward_only_to_rc_type
            ),
            a(str("description"), quote | arg),
            a(str("maximum-hop-count"), arg),
            a(str("minimum-wait-time"), arg),
            a(str("client-response-ttl"), arg),
            str("source-ip-change"),
            str("forward-only-replies"),
            b(str("server-group"),
              server_group_type
            ),
            b(str("active-server-group"),
              dhcpv4_gbl_active_sg_type
            ),
            b(str("route-suppression"),
              dhcp_route_suppression_type
            ),
            b(str("group"),
              dhcp_group
            ),
            b(str("dual-stack-group"),
              dhcp_dual_stack_group
            ),
            str("no-snoop"),
            a(str("server-response-time"), arg),
            b(str("lease-time-validation"),
                c(
                    a(str("lease-time-threshold"), arg),
                    b(str("violation-action"),
                        sc(
                            str("drop")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("leasequery"),
              relay_leasequery_type
            ),
            b(str("bulk-leasequery"),
              relay_bulk_leasequery_v4_type
            ),
            b(str("active-leasequery"),
              relay_active_leasequery_v4_type
            ),
            b(str("remote-id-mismatch"),
              dhcp_remote_id_mismatch_type
            )
        )
    end

    rule(:authentication_type) do
        c(
            a(str("password"), arg),
            b(str("username-include"),
                c(
                    a(str("delimiter"), arg),
                    a(str("domain-name"), arg),
                    a(str("user-prefix"), arg),
                    str("mac-address"),
                    b(str("option-82"),
                        sc(
                            str("circuit-id"),
                            str("remote-id")
                        )
                    ).as(:oneline),
                    str("logical-system-name"),
                    str("routing-instance-name"),
                    str("option-60"),
                    str("circuit-type"),
                    str("interface-name"),
                    b(str("interface-description"),
                      (str("device") | str("logical"))
                    ),
                    str("vlan-tags")
                )
            )
        )
    end

    rule(:dhcp_dual_stack_group) do
      b(arg.as(:arg),
        c(
            b(str("authentication"),
              dual_stack_authentication_type
            ),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            b(str("liveness-detection"),
              dhcp_liveness_detection_dualstack_type
            ),
            b(str("relay-agent-interface-id"),
              v6_relay_option_interface_id_type
            ),
            b(str("relay-agent-remote-id"),
              v6_relay_option_remote_id_type
            ),
            b(str("classification-key"),
              classification_types
            ),
            a(str("dual-stack-interface-client-limit"), arg),
            b(str("protocol-master"),
              jdhcp_dual_stack_protocol_mstr_type
            ).as(:oneline),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:classification_types) do
        c(
            str("mac-address"),
            str("circuit-id"),
            str("remote-id")
        )
    end

    rule(:dhcp_generic_v4_option) do
        c(
            b(str("option-number"),
              (str("60") | str("77"))
            ),
            b(str("equals"),
              relay_v4_option_ascii_hex
            ),
            b(str("default-action"),
              dhcp_v4_option_default_action
            ),
            b(str("starts-with"),
              relay_v4_option_ascii_hex
            ),
            b(str("option-60"),
              dhcp_generic_v4_option_type
            ),
            b(str("option-77"),
              dhcp_generic_v4_option_type
            ),
            a(str("option-order"), enum(str("60") | str("77")))
        )
    end

    rule(:dhcp_generic_v4_option_type) do
        c(
            b(str("equals"),
              relay_v4_option_ascii_hex
            ),
            b(str("default-action"),
              dhcp_v4_option_default_action
            ),
            b(str("starts-with"),
              relay_v4_option_ascii_hex
            )
        )
    end

    rule(:dhcp_group) do
      b(arg.as(:arg),
        c(
            b(str("active-server-group"),
              dhcpv4_gp_active_sg_type
            ),
            b(str("authentication"),
              authentication_type
            ),
            b(str("liveness-detection"),
              dhcp_liveness_detection_type
            ),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("overrides"),
              override_type
            ),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline),
            b(str("server-match"),
                c(
                    b(str("default-action"),
                      server_match_action_choice
                    ),
                    b(a(str("address"), arg),
                        c(
                            c(
                              str("forward-only"),
                              str("create-relay-entry")
                            )
                        )
                    )
                )
            ),
            b(str("relay-option"),
              dhcp_generic_v4_option
            ),
            b(str("relay-option-60"),
              relay_option_60_type_group
            ),
            b(str("relay-option-82"),
              relay_option_82_type
            ),
            b(str("forward-only"),
              forward_only_to_rc_type
            ),
            b(str("route-suppression"),
              dhcp_route_suppression_type
            ),
            a(str("description"), quote | arg),
            a(str("maximum-hop-count"), arg),
            a(str("minimum-wait-time"), arg),
            a(str("client-response-ttl"), arg),
            str("source-ip-change"),
            b(a(str("interface"), arg),
                c(
                    b(str("upto"),
                      interface_name
                    ),
                    str("exclude"),
                    str("trace"),
                    b(str("overrides"),
                      override_type
                    ),
                    b(str("dynamic-profile"),
                      dynamic_profile_type
                    ).as(:oneline),
                    a(str("service-profile"), arg),
                    a(str("access-profile"), arg),
                    b(str("short-cycle-protection"),
                        sc(
                            a(str("lockout-min-time"), arg),
                            a(str("lockout-max-time"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("remote-id-mismatch"),
              dhcp_remote_id_mismatch_type
            ),
            b(str("lease-time-validation"),
                c(
                    a(str("lease-time-threshold"), arg),
                    b(str("violation-action"),
                        sc(
                            str("drop")
                        )
                    ).as(:oneline)
                )
            )
        )
      )
    end

    rule(:dhcp_liveness_detection_dualstack_type) do
        c(
            b(str("failure-action"),
              dhcp_liveness_detection_failure_action_type
            ).as(:oneline),
            b(str("method"),
                c(
                    c(
                      b(str("layer2-liveness-detection"),
                        dhcp_arp_nud_liveness_detection_type
                      )
                    )
                )
            )
        )
    end

    rule(:dhcp_arp_nud_liveness_detection_type) do
        c(
            a(str("transmit-interval"), arg),
            a(str("max-consecutive-retries"), arg)
        )
    end

    rule(:dhcp_liveness_detection_failure_action_type) do
        c(
            c(
              str("clear-binding"),
              str("clear-binding-if-interface-up"),
              str("log-only")
            )
        ).as(:oneline)
    end

    rule(:dhcp_liveness_detection_type) do
        c(
            b(str("failure-action"),
              dhcp_liveness_detection_failure_action_type
            ).as(:oneline),
            b(str("method"),
                c(
                    c(
                      b(str("bfd"),
                        dhcp_bfd_liveness_detection_type
                      ),
                      b(str("layer2-liveness-detection"),
                        dhcp_arp_nud_liveness_detection_type
                      )
                    )
                )
            )
        )
    end

    rule(:dhcp_bfd_liveness_detection_type) do
        c(
            b(str("version"),
              (str("0") | str("1") | str("automatic"))
            ),
            a(str("minimum-interval"), arg),
            a(str("minimum-transmit-interval"), arg),
            a(str("minimum-receive-interval"), arg),
            a(str("multiplier"), arg),
            c(
              str("no-adaptation")
            ),
            b(str("transmit-interval"),
                c(
                    a(str("minimum-interval"), arg),
                    a(str("threshold"), arg)
                )
            ),
            b(str("detection-time"),
                c(
                    a(str("threshold"), arg)
                )
            ),
            b(str("session-mode"),
              (str("automatic") | str("single-hop") | str("multihop"))
            ),
            a(str("holddown-interval"), arg)
        )
    end

    rule(:dhcp_remote_id_mismatch_type) do
        c(
            str("disconnect")
        )
    end

    rule(:dhcp_route_suppression_type) do
        c(
            c(
              str("access-internal"),
              str("destination")
            )
        )
    end

    rule(:dhcp_v4_option_default_action) do
        c(
            c(
              a(str("relay-server-group"), arg),
              a(str("local-server-group"), arg),
              str("drop"),
              str("forward-only")
            )
        )
    end

    rule(:dhcpv4_gbl_active_sg_type) do
        ca(
            str("allow-server-change")
        ).as(:oneline)
    end

    rule(:dhcpv4_gp_active_sg_type) do
        ca(
            str("allow-server-change")
        ).as(:oneline)
    end

    rule(:dhcpv6_relay_type) do
        c(
            b(str("authentication"),
              dhcpv6_authentication_type
            ),
            b(str("persistent-storage"),
                sc(
                    str("automatic")
                )
            ).as(:oneline),
            b(str("liveness-detection"),
              dhcpv6_liveness_detection_type
            ),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline),
            b(str("overrides"),
              dhcpv6_override_relay_type
            ),
            b(str("relay-option"),
              dhcp_generic_v6_option
            ),
            str("exclude-relay-agent-identifier"),
            b(str("server-match"),
                c(
                    b(str("default-action"),
                      server_match_action_choice
                    ),
                    b(str("duid"),
                        c(
                            b(str("equals"),
                              server_match_v6_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_match_v6_ascii_hex
                            )
                        )
                    ),
                    b(a(str("address"), arg),
                        c(
                            c(
                              str("forward-only"),
                              str("create-relay-entry")
                            )
                        )
                    )
                )
            ),
            str("relay-agent-option-79"),
            b(str("vendor-specific-information"),
              jdhcp_vendor_specific_type
            ),
            b(str("forward-only"),
              forward_only_to_rc_type
            ),
            str("forward-only-replies"),
            b(str("forward-snooped-clients"),
                sc(
                    c(
                      str("configured-interfaces"),
                      str("non-configured-interfaces"),
                      str("all-interfaces")
                    )
                )
            ).as(:oneline),
            b(str("route-suppression"),
              dhcpv6_route_suppression_type
            ),
            b(str("group"),
              dhcpv6_relay_group
            ),
            b(str("relay-agent-interface-id"),
              v6_relay_option_interface_id_type
            ),
            b(str("relay-agent-remote-id"),
              v6_relay_option_remote_id_type
            ),
            b(str("server-group"),
              v6_server_group_type
            ),
            b(str("active-server-group"),
              dhcpv6_gbl_active_sg_type
            ),
            a(str("server-response-time"), arg),
            b(str("lease-time-validation"),
                c(
                    a(str("lease-time-threshold"), arg),
                    b(str("violation-action"),
                        sc(
                            str("drop")
                        )
                    ).as(:oneline)
                )
            ),
            str("no-snoop"),
            b(str("leasequery"),
              relay_leasequery_type
            ),
            b(str("bulk-leasequery"),
              relay_bulk_leasequery_v6_type
            ),
            b(str("active-leasequery"),
              relay_active_leasequery_v6_type
            ),
            b(str("remote-id-mismatch"),
              dhcp_remote_id_mismatch_type
            ),
            b(str("duplicate-clients"),
              dhcpv6_duplicate_clients_type
            ).as(:oneline)
        )
    end

    rule(:dhcp_generic_v6_option) do
        c(
            b(str("option-number"),
              (str("15") | str("16"))
            ),
            b(str("equals"),
              relay_v6_option_ascii_hex
            ),
            b(str("default-action"),
              dhcp_v6_option_default_action
            ),
            b(str("starts-with"),
              relay_v6_option_ascii_hex
            ),
            b(str("option-15"),
              dhcp_generic_v6_option_type
            ),
            b(str("option-16"),
              dhcp_generic_v6_option_type
            ),
            a(str("option-order"), enum(str("15") | str("16")))
        )
    end

    rule(:dhcp_generic_v6_option_type) do
        c(
            b(str("equals"),
              relay_v6_option_ascii_hex
            ),
            b(str("default-action"),
              dhcp_v6_option_default_action
            ),
            b(str("starts-with"),
              relay_v6_option_ascii_hex
            )
        )
    end

    rule(:dhcp_v6_option_default_action) do
        c(
            c(
              a(str("relay-server-group"), arg),
              str("drop"),
              str("forward-only")
            )
        )
    end

    rule(:dhcpv6_authentication_type) do
        c(
            a(str("password"), arg),
            b(str("username-include"),
                c(
                    a(str("delimiter"), arg),
                    a(str("domain-name"), arg),
                    a(str("user-prefix"), arg),
                    str("mac-address"),
                    str("client-id"),
                    b(str("relay-agent-remote-id"),
                        c(
                            c(
                              str("enterprise-id"),
                              str("remote-id")
                            )
                        )
                    ),
                    str("logical-system-name"),
                    str("routing-instance-name"),
                    str("relay-agent-subscriber-id"),
                    str("relay-agent-interface-id"),
                    str("circuit-type"),
                    str("interface-name"),
                    b(str("interface-description"),
                      (str("device") | str("logical"))
                    ),
                    str("vlan-tags")
                )
            )
        )
    end

    rule(:dhcpv6_duplicate_clients_type) do
        c(
            c(
              str("incoming-interface")
            )
        ).as(:oneline)
    end

    rule(:dhcpv6_gbl_active_sg_type) do
        c(
              arg
        )
    end

    rule(:dhcpv6_liveness_detection_type) do
        c(
            b(str("failure-action"),
              dhcp_liveness_detection_failure_action_type
            ).as(:oneline),
            b(str("method"),
                c(
                    c(
                      b(str("bfd"),
                        dhcp_bfd_liveness_detection_type
                      ),
                      b(str("layer2-liveness-detection"),
                        dhcp_arp_nud_liveness_detection_type
                      )
                    )
                )
            )
        )
    end

    rule(:dhcpv6_override_relay_type) do
        c(
            str("allow-snooped-clients"),
            str("no-allow-snooped-clients"),
            str("delay-authentication"),
            a(str("interface-client-limit"), arg),
            a(str("dual-stack"), arg),
            str("no-bind-on-request"),
            b(str("client-negotiation-match"),
                sc(
                    c(
                      str("incoming-interface")
                    )
                )
            ).as(:oneline),
            str("send-release-on-delete"),
            str("always-process-option-request-option"),
            b(str("relay-source"),
              interface_name
            ),
            str("delete-binding-on-renegotiation"),
            a(str("asymmetric-lease-time"), arg),
            a(str("asymmetric-prefix-lease-time"), arg)
        )
    end

    rule(:dhcpv6_relay_group) do
      b(arg.as(:arg),
        c(
            b(str("active-server-group"),
              dhcpv6_gp_active_sg_type
            ),
            b(str("dual-stack-group"),
              dhcp_dual_stack_group
            ),
            b(str("authentication"),
              dhcpv6_authentication_type
            ),
            b(str("liveness-detection"),
              dhcpv6_liveness_detection_type
            ),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline),
            b(str("overrides"),
              dhcpv6_override_relay_type
            ),
            b(str("relay-option"),
              dhcp_generic_v6_option
            ),
            b(str("vendor-specific-information"),
              jdhcp_vendor_specific_type
            ),
            b(str("forward-only"),
              forward_only_to_rc_type
            ),
            b(str("relay-agent-interface-id"),
              v6_relay_option_interface_id_type
            ),
            b(str("relay-agent-remote-id"),
              v6_relay_option_remote_id_type
            ),
            b(str("route-suppression"),
              dhcpv6_route_suppression_type
            ),
            str("relay-agent-option-79"),
            b(a(str("interface"), arg),
                c(
                    b(str("upto"),
                      interface_name
                    ),
                    str("exclude"),
                    str("trace"),
                    b(str("overrides"),
                      dhcpv6_override_relay_type
                    ),
                    b(str("dynamic-profile"),
                      dynamic_profile_type
                    ).as(:oneline),
                    a(str("service-profile"), arg),
                    a(str("access-profile"), arg),
                    b(str("short-cycle-protection"),
                        sc(
                            a(str("lockout-min-time"), arg),
                            a(str("lockout-max-time"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("lease-time-validation"),
                c(
                    a(str("lease-time-threshold"), arg),
                    b(str("violation-action"),
                        sc(
                            str("drop")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("remote-id-mismatch"),
              dhcp_remote_id_mismatch_type
            ),
            b(str("server-match"),
                c(
                    b(str("default-action"),
                      server_match_action_choice
                    ),
                    b(str("duid"),
                        c(
                            b(str("equals"),
                              server_match_v6_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_match_v6_ascii_hex
                            )
                        )
                    ),
                    b(a(str("address"), arg),
                        c(
                            c(
                              str("forward-only"),
                              str("create-relay-entry")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:dhcpv6_gp_active_sg_type) do
        c(
              arg
        )
    end

    rule(:dhcpv6_route_suppression_type) do
        c(
            str("access"),
            str("access-internal")
        ).as(:oneline)
    end

    rule(:dual_stack_authentication_type) do
        c(
            a(str("password"), arg),
            b(str("username-include"),
                c(
                    a(str("delimiter"), arg),
                    a(str("domain-name"), arg),
                    a(str("user-prefix"), arg),
                    str("mac-address"),
                    str("relay-agent-remote-id"),
                    str("logical-system-name"),
                    str("routing-instance-name"),
                    str("relay-agent-interface-id"),
                    str("interface-name"),
                    b(str("interface-description"),
                      (str("device") | str("logical"))
                    ),
                    str("circuit-type"),
                    str("vlan-tags")
                )
            )
        )
    end

    rule(:dynamic_profile_type) do
        ca(
            c(
              a(str("use-primary"), arg),
              b(str("aggregate-clients"),
                  c(
                      c(
                        str("merge"),
                        str("replace")
                      )
                  )
              )
            )
        ).as(:oneline)
    end

    rule(:forward_only_to_rc_type) do
        c(
            b(str("logical-system"),
              (str("default") | str("current") | arg)
            ),
            b(str("routing-instance"),
              (str("default") | str("current") | arg)
            )
        )
    end

    rule(:jdhcp_dual_stack_protocol_mstr_type) do
        c(
            c(
              str("inet6"),
              str("inet")
            )
        ).as(:oneline)
    end

    rule(:jdhcp_duplicate_clients_in_subnet_type) do
        c(
            c(
              str("incoming-interface"),
              str("option-82")
            )
        ).as(:oneline)
    end

    rule(:jdhcp_interface_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("state") | str("packet") | str("flow") | str("packet-option") | str("dhcpv6-state") | str("dhcpv6-packet") | str("dhcpv6-packet-option") | str("all"))).as(:oneline)
        )
    end

    rule(:jdhcp_security_type) do
        c(
            str("no-dhcp-snooping"),
            str("arp-inspection"),
            str("ip-source-guard"),
            str("no-dhcpv6-snooping"),
            str("neighbor-discovery-inspection"),
            str("ipv6-source-guard"),
            str("light-weight-dhcpv6-relay"),
            b(str("group"),
              ds_group
            ),
            b(str("option-82"),
              security_option_82_type
            ),
            b(str("dhcpv6-options"),
              security_dhcpv6_options_type
            )
        )
    end

    rule(:ds_group) do
      b(arg.as(:arg),
        c(
            b(str("overrides"),
              ds_override_type
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("static-ip"),
                      ip_mac_static
                    ),
                    b(str("static-ipv6"),
                      ipv6_mac_static
                    )
                )
            )
        )
      )
    end

    rule(:ds_override_type) do
        c(
            str("trusted"),
            str("untrusted"),
            str("no-option82"),
            str("no-option37"),
            str("no-option18"),
            str("no-option16"),
            str("no-option79"),
            str("no-dhcpv6-options")
        )
    end

    rule(:ip_mac_static) do
      b(arg.as(:arg),
        c(
            b(str("mac"),
              mac_addr
            )
        )
      ).as(:oneline)
    end

    rule(:ipv6_mac_static) do
      b(arg.as(:arg),
        c(
            b(str("mac"),
              mac_addr
            )
        )
      ).as(:oneline)
    end

    rule(:jdhcp_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("state") | str("packet") | str("flow") | str("packet-option") | str("dhcpv6-state") | str("dhcpv6-packet") | str("dhcpv6-packet-option") | str("all") | str("database") | str("persistent") | str("lockout-db") | str("interface") | str("rtsock") | str("flow-notify") | str("io") | str("ha") | str("ui") | str("general") | str("fwd") | str("rpd") | str("auth") | str("profile") | str("session-db") | str("performance") | str("statistics") | str("dhcpv6-io") | str("dhcpv6-rpd") | str("dhcpv6-session-db") | str("dhcpv6-general") | str("liveness-detection") | str("security-persistence") | str("mclag") | str("ra-guard"))).as(:oneline)
        )
    end

    rule(:jdhcp_vendor_specific_type) do
        c(
            str("host-name"),
            str("location")
        ).as(:oneline)
    end

    rule(:juniper_cdr_profiles) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            str("enable-reduced-partial-cdrs"),
            str("report-requested-apn"),
            b(str("exclude-attributes"),
                c(
                    str("apn-ni"),
                    str("apn-selection-mode"),
                    str("cc-selection-mode"),
                    str("dynamic-address"),
                    str("pgw-plmn-identifier"),
                    str("list-of-traffic-volumes"),
                    str("list-of-service-data"),
                    str("lrsn"),
                    str("ms-time-zone"),
                    str("network-initiation"),
                    str("node-id"),
                    str("pdn-connection-id"),
                    str("pdppdn-type"),
                    str("rat-type"),
                    str("record-sequence-number"),
                    str("served-imeisv"),
                    str("served-msisdn"),
                    str("served-pdppdn-address"),
                    str("serving-node-plmn-identifier"),
                    str("start-time"),
                    str("stop-time"),
                    str("user-location-information"),
                    str("sgw-change"),
                    str("pgw-address-used"),
                    str("ps-furnish-info"),
                    str("served-pdp-address-extension")
                )
            ),
            b(str("node-id"),
              (str("hostname") | str("hostname-spic") | str("ipaddress-spic"))
            )
        )
      )
    end

    rule(:juniper_charged_configuraton) do
        c(
            b(str("file-age"),
                sc(
                      arg,
                    str("disable")
                )
            ).as(:oneline),
            b(str("file-size"),
                sc(
                      arg,
                    str("disable")
                )
            ).as(:oneline),
            a(str("cdrs-per-file"), arg),
            a(str("user-name"), arg),
            str("disable-replication"),
            str("world-readable"),
            b(str("file-format"),
              (str("3gpp") | str("raw-asn"))
            ),
            a(str("file-name-private-extension"), arg),
            b(str("file-creation-policy"),
              (str("shared-file") | str("unique-file"))
            ),
            b(str("disk-space-policy"),
                c(
                    b(str("water-mark-level1"),
                        c(
                            a(str("percentage"), arg),
                            b(str("notification-level"),
                              (str("snmp-alarm") | str("syslog") | str("both"))
                            )
                        )
                    ),
                    b(str("water-mark-level2"),
                        c(
                            a(str("percentage"), arg),
                            b(str("notification-level"),
                              (str("snmp-alarm") | str("syslog") | str("both"))
                            )
                        )
                    ),
                    b(str("water-mark-level3"),
                        c(
                            a(str("percentage"), arg),
                            b(str("notification-level"),
                              (str("snmp-alarm") | str("syslog") | str("both"))
                            )
                        )
                    )
                )
            ),
            b(str("traceoptions"),
              charged_traceoptions_type
            )
        )
    end

    rule(:charged_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("general") | str("mirror") | str("connection") | str("file-operations") | str("journaling") | str("all"))).as(:oneline)
        )
    end

    rule(:juniper_charging_profiles) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("profile-id"), arg),
            a(str("default-service-id"), arg),
            a(str("default-rating-group"), arg),
            a(str("default-l7-rating-group"), arg),
            b(str("transport-profile"),
                c(
                      arg
                )
            ),
            b(str("cdr-profile"),
                c(
                      arg
                )
            ),
            b(a(str("trigger-profile"), arg),
                c(
                    a(str("rating-group"), arg)
                )
            ),
            b(str("service-mode"),
              (str("maintenance"))
            )
        )
      )
    end

    rule(:juniper_class_of_service_options) do
        c(
            b(str("classifiers"),
                c(
                    b(a(str("dscp"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("dscp-ipv6"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("exp"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("ieee-802.1"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("inet-precedence"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("ieee-802.1ad"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("traffic-class-map"),
                c(
                    b(a(str("inet-precedence"), arg),
                        c(
                            a(str("traffic-class"), str("real-time") | str("network-control") | str("best-effort"),
                                sc(
                                    a(str("code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("dscp"), arg),
                        c(
                            a(str("traffic-class"), str("real-time") | str("network-control") | str("best-effort"),
                                sc(
                                    a(str("code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("exp"), arg),
                        c(
                            a(str("traffic-class"), str("real-time") | str("network-control") | str("best-effort"),
                                sc(
                                    a(str("code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("ieee-802.1"), arg),
                        c(
                            a(str("traffic-class"), str("real-time") | str("network-control") | str("best-effort"),
                                sc(
                                    a(str("code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("ieee-802.1ad"), arg),
                        c(
                            a(str("traffic-class"), str("real-time") | str("network-control") | str("best-effort"),
                                sc(
                                    a(str("code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(a(str("policy-map"), arg),
                c(
                    a(str("inet-precedence"), str("proto-ip") | str("proto-mpls"),
                        sc(
                            a(str("code-point"), arg)
                        )
                    ).as(:oneline),
                    a(str("dscp"), str("proto-ip") | str("proto-mpls"),
                        sc(
                            a(str("code-point"), arg)
                        )
                    ).as(:oneline),
                    a(str("dscp-ipv6"), str("proto-ip") | str("proto-mpls"),
                        sc(
                            a(str("code-point"), arg)
                        )
                    ).as(:oneline),
                    a(str("exp"), str("all-label") | str("outer-label"),
                        sc(
                            a(str("code-point"), arg)
                        )
                    ).as(:oneline),
                    a(str("ieee-802.1"), str("outer") | str("outer-and-inner"),
                        sc(
                            a(str("code-point"), arg)
                        )
                    ).as(:oneline),
                    a(str("ieee-802.1ad"), str("outer") | str("outer-and-inner"),
                        sc(
                            a(str("code-point"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("forwarding-class-map"), arg),
                c(
                    b(a(str("class"), arg),
                        sc(
                            a(str("queue-num"), arg),
                            a(str("restricted-queue"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("loss-priority-maps"),
                c(
                    b(a(str("frame-relay-de"), arg),
                        c(
                            a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                sc(
                                    a(str("code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("loss-priority-rewrites"),
                c(
                    b(a(str("frame-relay-de"), arg),
                        c(
                            a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                sc(
                                    a(str("code-point"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("code-point-aliases"),
                c(
                    b(a(str("dscp"), arg),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(a(str("dscp-ipv6"), arg),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(a(str("exp"), arg),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(a(str("ieee-802.1"), arg),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(a(str("inet-precedence"), arg),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(a(str("ieee-802.1ad"), arg),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(a(str("inet6-precedence"), arg),
                        sc(
                            arg
                        )
                    ).as(:oneline)
                )
            ),
            b(str("translation-table"),
                c(
                    b(a(str("to-802.1p-from-dscp"), arg),
                        c(
                            b(a(str("to-code-point"), arg),
                                sc(
                                    a(str("from-code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("to-inet-precedence-from-inet-precedence"), arg),
                        c(
                            b(a(str("to-code-point"), arg),
                                sc(
                                    a(str("from-code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("to-dscp-from-dscp"), arg),
                        c(
                            b(a(str("to-code-point"), arg),
                                sc(
                                    a(str("from-code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("to-dscp-ipv6-from-dscp-ipv6"), arg),
                        c(
                            b(a(str("to-code-point"), arg),
                                sc(
                                    a(str("from-code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("to-exp-from-exp"), arg),
                        c(
                            b(a(str("to-code-point"), arg),
                                sc(
                                    a(str("from-code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("host-outbound-traffic"),
                c(
                    a(str("forwarding-class"), arg),
                    a(str("dscp-code-point"), arg),
                    str("override-firewall"),
                    b(str("translation-table"),
                        sc(
                            a(str("to-802.1p-from-dscp"), arg)
                        )
                    ).as(:oneline),
                    b(str("tcp"),
                        c(
                            str("raise-internet-control-priority")
                        )
                    ),
                    b(str("ieee-802.1"),
                        c(
                            str("rewrite-rules"),
                            a(str("default"), arg)
                        )
                    ),
                    b(str("protocol"),
                        c(
                            b(str("isis-over-gre"),
                                c(
                                    a(str("dscp-code-point"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("drop-profiles"), arg),
                c(
                    b(a(str("fill-level"), arg),
                        sc(
                            a(str("drop-probability"), arg)
                        )
                    ).as(:oneline),
                    b(str("interpolate"),
                        c(
                            a(str("fill-level"), arg),
                            a(str("drop-probability"), arg)
                        )
                    )
                )
            ),
            b(a(str("adaptive-shapers"), arg),
                c(
                    a(str("trigger"), enum(str("becn")),
                        sc(
                            b(str("shaping-rate"),
                                sc(
                                    ca(
                                      a(str("percent"), arg)
                                    )
                                )
                            ).as(:oneline)
                        )
                    ).as(:oneline)
                )
            ),
            a(str("virtual-channels"), arg),
            b(a(str("virtual-channel-groups"), arg),
                c(
                        c(
                            a(str("scheduler-map"), arg),
                            b(str("shaping-rate"),
                                sc(
                                    ca(
                                      a(str("percent"), arg)
                                    )
                                )
                            ).as(:oneline),
                            str("default")
                        )
                )
            ),
            str("copy-plp-all"),
            str("tri-color"),
            str("non-strict-priority-scheduling"),
            b(str("shared-buffer"),
                c(
                    a(str("percent"), arg),
                    b(str("ingress"),
                        c(
                            a(str("percent"), arg),
                            b(a(str("buffer-partition"), arg),
                                c(
                                    a(str("percent"), arg),
                                    a(str("dynamic-threshold"), arg)
                                )
                            )
                        )
                    ),
                    b(str("egress"),
                        c(
                            a(str("percent"), arg),
                            b(a(str("buffer-partition"), arg),
                                c(
                                    a(str("percent"), arg),
                                    a(str("dynamic-threshold"), arg)
                                )
                            )
                        )
                    ),
                    b(a(str("node-group"), arg),
                        c(
                            b(str("ingress"),
                                c(
                                    a(str("percent"), arg),
                                    b(a(str("buffer-partition"), arg),
                                        c(
                                            a(str("percent"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("egress"),
                                c(
                                    a(str("percent"), arg),
                                    b(a(str("buffer-partition"), arg),
                                        c(
                                            a(str("percent"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("forwarding-classes"),
                c(
                    b(a(str("class"), arg),
                        sc(
                            a(str("queue-num"), arg),
                            b(str("priority"),
                              (str("low") | str("high"))
                            ),
                            b(str("policing-priority"),
                              (str("normal") | str("premium"))
                            ),
                            str("no-loss"),
                            a(str("pfc-priority"), arg),
                            b(str("spu-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high") | str("medium"))
                            )
                        )
                    ).as(:oneline),
                    b(a(str("queue"), arg),
                        sc(
                              arg,
                            b(str("priority"),
                              (str("low") | str("high"))
                            ),
                            b(str("policing-priority"),
                              (str("normal") | str("premium"))
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("restricted-queues"),
                c(
                    b(a(str("forwarding-class"), arg),
                        sc(
                              arg
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("traffic-control-profiles"), arg),
                c(
                    a(str("scheduler-map"), arg),
                    str("strict-priority-scheduler"),
                    b(str("atm-service"),
                      (str("cbr") | str("rtvbr") | str("nrtvbr"))
                    ),
                    a(str("peak-rate"), arg),
                    a(str("sustained-rate"), arg),
                    a(str("max-burst-size"), arg),
                    b(str("shaping-rate"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("overhead-accounting"),
                        sc(
                              arg,
                            a(str("bytes"), arg),
                            a(str("frame-mode-bytes"), arg),
                            a(str("cell-mode-bytes"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-priority-strict-high"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-priority-high"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-priority-medium"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-priority-medium-low"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-priority-low"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-excess-high"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-excess-low"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-excess-medium-high"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("shaping-rate-excess-medium-low"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("guaranteed-rate"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("excess-rate"),
                        sc(
                            c(
                              a(str("proportion"), arg),
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("excess-rate-high"),
                        sc(
                            c(
                              a(str("proportion"), arg),
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("excess-rate-medium-high"),
                        sc(
                            c(
                              a(str("proportion"), arg),
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("excess-rate-low"),
                        sc(
                            c(
                              a(str("proportion"), arg),
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("excess-rate-medium-low"),
                        sc(
                            c(
                              a(str("proportion"), arg),
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    c(
                      b(str("delay-buffer-rate"),
                          sc(
                              ca(
                                a(str("percent"), arg),
                                a(str("cps"), arg)
                              )
                          )
                      ).as(:oneline)
                    ),
                    b(str("adjust-minimum"),
                        sc(
                            arg
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("forwarding-class-sets"), arg),
                c(
                    a(str("class"), arg)
                )
            ),
            b(a(str("congestion-notification-profile"), arg),
                c(
                    b(str("input"),
                        c(
                            a(str("cable-length"), arg),
                            b(str("ieee-802.1"),
                                c(
                                    b(a(str("code-point"), arg),
                                        c(
                                            str("pfc"),
                                            a(str("mru"), arg),
                                            c(
                                              str("qfc"),
                                              b(str("qcn"),
                                                  c(
                                                      b(str("defense-mode-edge"),
                                                          c(
                                                              b(str("alternate-priority"),
                                                                  c(
                                                                      arg
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("dscp"),
                                c(
                                    b(a(str("code-point"), arg),
                                        c(
                                            str("pfc"),
                                            a(str("mru"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("output"),
                        c(
                            b(a(str("class"), arg),
                                c(
                                    str("remove-cntag"),
                                    str("qcn")
                                )
                            ),
                            b(str("ieee-802.1"),
                                c(
                                    b(a(str("code-point"), arg),
                                        c(
                                            a(str("flow-control-queue"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("scheduler-map-forwarding-class-sets"), arg),
                c(
                    b(a(str("forwarding-class-set"), arg),
                        sc(
                            a(str("scheduler"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("system-defaults"),
                c(
                    b(str("classifiers"),
                        c(
                            b(str("exp"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("traffic-control-profiles"),
                        c(
                            b(str("interface-set-input"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("interface-set-output"),
                                sc(
                                      arg
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("dynamic-class-of-service-options"),
                c(
                    a(str("vendor-specific-tags"), enum(str("actual-data-rate-downstream") | str("access-loop-encapsulation") | str("apply-to-interface-set")))
                )
            ),
            b(str("interfaces"),
                c(
                    b(a(str("interface-set"), arg),
                        c(
                            str("internal-node"),
                            b(str("input-excess-bandwidth-share"),
                                sc(
                                    c(
                                      a(str("proportional"), arg),
                                      str("equal")
                                    )
                                )
                            ).as(:oneline),
                            b(str("excess-bandwidth-share"),
                                sc(
                                    c(
                                      a(str("proportional"), arg),
                                      str("equal")
                                    )
                                )
                            ).as(:oneline),
                            b(str("input-traffic-control-profile"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("input-traffic-control-profile-remaining"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("output-traffic-control-profile"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("output-traffic-control-profile-remaining"),
                                sc(
                                      arg
                                )
                            ).as(:oneline)
                        )
                    ),
                      cos_interfaces_type
                )
            ),
            b(a(str("routing-instances"), arg),
                c(
                    b(str("classifiers"),
                        c(
                            str("no-default"),
                            b(str("exp"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1"),
                                sc(
                                      (str("default")),
                                    str("encapsulated"),
                                    b(str("vlan-tag"),
                                      (str("outer") | str("inner"))
                                    )
                                )
                            ).as(:oneline),
                            b(str("dscp"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline),
                            b(str("dscp-ipv6"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("rewrite-rules"),
                        c(
                            c(
                              b(str("ieee-802.1"),
                                  sc(
                                        (str("default")),
                                      str("encapsulated"),
                                      b(str("vlan-tag"),
                                        (str("outer") | str("outer-and-inner"))
                                      )
                                  )
                              ).as(:oneline),
                              b(str("ieee-802.1ad"),
                                  sc(
                                        (str("default")),
                                      str("encapsulated"),
                                      b(str("vlan-tag"),
                                        (str("outer") | str("outer-and-inner"))
                                      )
                                  )
                              ).as(:oneline)
                            )
                        )
                    ),
                    b(str("policy-map"),
                        sc(
                            arg
                        )
                    ).as(:oneline)
                )
            ),
            b(str("rewrite-rules"),
                c(
                    b(a(str("dscp"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("dscp-ipv6"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("exp"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("ieee-802.1"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("inet-precedence"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("frame-relay-de"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("ieee-802.1ad"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("inet6-precedence"), arg),
                        c(
                            b(str("import"),
                              (str("default"))
                            ),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        sc(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("fabric"),
                c(
                    b(str("scheduler-map"),
                        c(
                            a(str("priority"), enum(str("low") | str("high")),
                                sc(
                                    a(str("scheduler"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(a(str("scheduler-maps"), arg),
                c(
                    b(a(str("forwarding-class"), arg),
                        sc(
                            a(str("scheduler"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("fragmentation-maps"), arg),
                c(
                    b(a(str("forwarding-class"), arg),
                        c(
                            c(
                              a(str("fragment-threshold"), arg),
                              str("no-fragmentation")
                            ),
                            a(str("multilink-class"), arg),
                            a(str("drop-timeout"), arg)
                        )
                    )
                )
            ),
            b(a(str("schedulers"), arg),
                c(
                    b(str("transmit-rate"),
                        c(
                            ca(
                              a(str("percent"), arg),
                              b(str("remainder"),
                                  c(
                                        arg
                                  )
                              )
                            ),
                            c(
                              str("exact"),
                              str("rate-limit")
                            )
                        )
                    ),
                    b(str("excess-rate"),
                        sc(
                            c(
                              a(str("proportion"), arg),
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("shaping-rate"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("buffer-size"),
                        c(
                            c(
                              a(str("percent"), arg),
                              b(str("remainder"),
                                  c(
                                        arg
                                  )
                              ),
                              str("shared"),
                              a(str("temporal"), arg)
                            ),
                            c(
                              str("exact")
                            ),
                            b(str("buffer-partition"),
                                c(
                                    b(str("multicast"),
                                        c(
                                            a(str("percent"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("shared-buffer"),
                        c(
                            b(str("maximum"),
                                ca(
                                    b(str("multicast"),
                                        c(
                                              arg
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("priority"), arg),
                    a(str("excess-priority"), arg),
                    b(str("drop-profile-map"),
                        s(
                          b(str("loss-priority"),
                                (str("low") | str("high") | str("medium-low") | str("medium-high") | str("any"))
                          ),
                          b(str("protocol"),
                                (str("tcp") | str("non-tcp") | str("any"))
                          ),
                          c(
                            a(str("drop-profile"), arg)
                          )
                        )
                    ).as(:oneline),
                    str("explicit-congestion-notification"),
                    b(str("drop-profile-map-set"),
                        ca(
                            b(str("profile-type"),
                              (str("drop") | str("mark"))
                            )
                        )
                    ),
                    a(str("adjust-percent"), arg),
                    a(str("adjust-minimum"), arg)
                )
            ),
            b(a(str("adjustment-control-profiles"), arg),
                c(
                    a(str("application"), enum(str("ancp") | str("radius-coa") | str("pppoe-tags") | str("dhcp-tags")),
                        sc(
                            a(str("priority"), arg),
                            b(str("algorithm"),
                              (str("adjust-less") | str("adjust-less-or-equal") | str("adjust-greater") | str("adjust-greater-or-equal") | str("adjust-always") | str("adjust-never"))
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("init") | str("show") | str("route-socket") | str("parse") | str("process") | str("util") | str("restart") | str("snmp") | str("hardware-database") | str("asynch") | str("dynamic") | str("cos-adjustment") | str("performance-monitor") | str("chassis-scheduler") | str("cn-util") | str("snmp-timeouts") | str("all") | str("feature-capability") | str("application"))).as(:oneline)
                )
            ),
            b(str("multi-destination"),
                c(
                    a(str("scheduler-map"), arg),
                    b(str("family"),
                        c(
                            b(str("ethernet"),
                                c(
                                    a(str("broadcast"), arg)
                                )
                            ),
                            b(str("inet"),
                                c(
                                    b(str("classifier"),
                                        c(
                                            b(str("dscp"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline),
                                            b(str("inet-precedence"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("classifier"),
                                        c(
                                            b(str("dscp-ipv6"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("classifiers"),
                        c(
                            b(str("ieee-802.1"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("dscp"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("dscp-ipv6"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("inet-precedence"),
                                sc(
                                      arg
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("forwarding-class"), arg)
                )
            ),
            b(str("application-traffic-control"),
                c(
                    b(str("traceoptions"),
                      appqos_traceoptions_type
                    ),
                    b(a(str("rate-limiters"), arg),
                        c(
                            a(str("bandwidth-limit"), arg),
                            a(str("burst-size-limit"), arg)
                        )
                    ),
                    b(a(str("rule-sets"), arg),
                        c(
                            b(str("rule"),
                              appqos_rule_type
                            )
                        )
                    )
                )
            ),
            b(str("forwarding-policy"),
                c(
                    b(a(str("next-hop-map"), arg),
                        c(
                            b(a(str("forwarding-class"), arg),
                                c(
                                    b(str("next-hop"),
                                      ipaddr_or_interface
                                    ),
                                    a(str("lsp-next-hop"), arg),
                                    str("non-lsp-next-hop"),
                                    str("non-labelled-next-hop"),
                                    str("discard")
                                )
                            ),
                            b(str("forwarding-class-default"),
                                c(
                                    b(str("next-hop"),
                                      ipaddr_or_interface
                                    ),
                                    a(str("lsp-next-hop"), arg),
                                    str("non-lsp-next-hop"),
                                    str("non-labelled-next-hop"),
                                    str("discard")
                                )
                            )
                        )
                    ),
                    b(a(str("class"), arg),
                        c(
                            b(str("classification-override"),
                                c(
                                    a(str("forwarding-class"), arg)
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:appqos_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("all"))).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            )
        )
    end

    rule(:appqos_rule_type) do
      b(arg.as(:arg),
        c(
            b(str("match"),
                c(
                    str("application-any"),
                    str("application-unknown"),
                    str("application-known"),
                    a(str("application"), arg),
                    a(str("application-group"), arg)
                )
            ),
            b(str("then"),
                c(
                    a(str("forwarding-class"), arg),
                    a(str("dscp-code-point"), arg),
                    b(str("loss-priority"),
                      (str("low") | str("medium-low") | str("medium-high") | str("high"))
                    ),
                    b(str("rate-limit"),
                        c(
                            a(str("client-to-server"), arg),
                            a(str("server-to-client"), arg),
                            str("loss-priority-high")
                        )
                    ),
                    str("log")
                )
            )
        )
      )
    end

    rule(:cos_interfaces_type) do
      b(arg.as(:arg),
        c(
            b(a(str("forwarding-class-set"), arg),
                c(
                    b(str("output-traffic-control-profile"),
                        sc(
                              arg
                        )
                    ).as(:oneline)
                )
            ),
            a(str("congestion-notification-profile"), arg),
            b(str("rewrite-value"),
                c(
                    b(str("input"),
                        c(
                            b(str("ieee-802.1"),
                                c(
                                    b(str("code-point"),
                                        c(
                                            arg
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            a(str("scheduler-map-forwarding-class-set"), arg),
            a(str("scheduler-map"), arg),
            a(str("input-scheduler-map"), arg),
            b(str("scheduler-map-chassis"),
              (str("derived"))
            ),
            a(str("output-forwarding-class-map"), arg),
            b(str("shaping-rate"),
                sc(
                    arg,
                    a(str("overhead"), arg)
                )
            ).as(:oneline),
            b(str("input-excess-bandwidth-share"),
                sc(
                    c(
                      a(str("proportional"), arg),
                      str("equal")
                    )
                )
            ).as(:oneline),
            b(str("excess-bandwidth-share"),
                sc(
                    c(
                      a(str("proportional"), arg),
                      str("equal")
                    )
                )
            ).as(:oneline),
            b(str("input-shaping-rate"),
                sc(
                    arg
                )
            ).as(:oneline),
            b(str("input-traffic-control-profile"),
                sc(
                      arg
                )
            ).as(:oneline),
            b(str("input-traffic-control-profile-remaining"),
                sc(
                      arg
                )
            ).as(:oneline),
            b(str("output-traffic-control-profile"),
                sc(
                      arg
                )
            ).as(:oneline),
            b(str("output-traffic-control-profile-remaining"),
                sc(
                      arg
                )
            ).as(:oneline),
            b(str("member-link-scheduler"),
                sc(
                    c(
                      str("scale"),
                      str("replicate")
                    )
                )
            ).as(:oneline),
            b(str("traffic-class-map"),
                c(
                    b(str("inet-precedence"),
                        c(
                              arg
                        )
                    ),
                    b(str("dscp"),
                        c(
                              arg
                        )
                    ),
                    b(str("exp"),
                        c(
                              arg
                        )
                    ),
                    b(str("ieee-802.1"),
                        ca(
                            b(str("vlan-tag"),
                              (str("outer") | str("inner"))
                            )
                        )
                    ),
                    b(str("ieee-802.1ad"),
                        ca(
                            b(str("vlan-tag"),
                              (str("outer") | str("inner"))
                            )
                        )
                    )
                )
            ),
            b(str("exclude-queue-overhead-bytes"),
                c(
                    str("include-hierarchy")
                )
            ),
            str("logical-interface-aggregate-statistics"),
            a(str("unit"), enum(str("*")),
                c(
                    a(str("output-forwarding-class-map"), arg),
                    a(str("forwarding-class"), arg),
                    a(str("virtual-channel-group"), arg),
                    str("vc-shared-scheduler"),
                    a(str("scheduler-map"), arg),
                    a(str("input-scheduler-map"), arg),
                    a(str("fragmentation-map"), arg),
                    a(str("adaptive-shaper"), arg),
                    b(str("shaping-rate"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("input-shaping-rate"),
                        sc(
                            ca(
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("input-traffic-control-profile"),
                        sc(
                              arg,
                            a(str("shared-instance"), arg)
                        )
                    ).as(:oneline),
                    b(str("output-traffic-control-profile"),
                        sc(
                              arg,
                            a(str("shared-instance"), arg)
                        )
                    ).as(:oneline),
                    b(str("output-traffic-control-profile-remaining"),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(str("report-ingress-shaping-rate"),
                        sc(
                            c(
                              arg
                            )
                        )
                    ).as(:oneline),
                    b(str("classifiers"),
                        c(
                            str("no-default"),
                            a(str("dscp"), str("default"),
                                c(
                                    a(str("family"), arg)
                                )
                            ),
                            a(str("dscp-ipv6"), str("default"),
                                c(
                                    a(str("family"), arg)
                                )
                            ),
                            b(str("exp"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1"),
                                sc(
                                      (str("default")),
                                    b(str("vlan-tag"),
                                      (str("outer") | str("inner") | str("transparent"))
                                    )
                                )
                            ).as(:oneline),
                            b(str("inet-precedence"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1ad"),
                                sc(
                                      (str("default")),
                                    b(str("vlan-tag"),
                                      (str("outer") | str("inner"))
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("ingress-rewrite-rules"),
                        c(
                            a(str("dscp"), str("default")).as(:oneline),
                            b(str("dscp-ipv6"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline),
                            a(str("inet-precedence"), str("default")).as(:oneline)
                        )
                    ),
                    b(str("loss-priority-maps"),
                        c(
                            b(str("frame-relay-de"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("rewrite-rules"),
                        c(
                            a(str("dscp"), str("default"),
                                sc(
                                    b(str("protocol"),
                                      (str("mpls") | str("gtp-inet-outer") | str("gtp-inet-both") | str("inet-outer") | str("inet-both"))
                                    )
                                )
                            ).as(:oneline),
                            a(str("dscp-ipv6"), str("default"),
                                sc(
                                    b(str("protocol"),
                                      (str("mpls") | str("gtp-inet-outer") | str("gtp-inet-both"))
                                    )
                                )
                            ).as(:oneline),
                            a(str("exp"), str("default"),
                                sc(
                                    b(str("protocol"),
                                      (str("mpls-any") | str("mpls-inet-both") | str("mpls-inet-both-non-vpn"))
                                    )
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1"),
                                sc(
                                      (str("default")),
                                    b(str("vlan-tag"),
                                      (str("outer") | str("outer-and-inner"))
                                    )
                                )
                            ).as(:oneline),
                            a(str("inet-precedence"), str("default"),
                                sc(
                                    b(str("protocol"),
                                      (str("mpls") | str("gtp-inet-outer") | str("gtp-inet-both") | str("inet-outer") | str("inet-both"))
                                    )
                                )
                            ).as(:oneline),
                            b(str("exp-swap-push-push"),
                                sc(
                                    c(
                                      str("default")
                                    )
                                )
                            ).as(:oneline),
                            b(str("exp-push-push-push"),
                                sc(
                                    c(
                                      str("default")
                                    )
                                )
                            ).as(:oneline),
                            b(str("frame-relay-de"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1ad"),
                                c(
                                      (str("default")),
                                    b(str("vlan-tag"),
                                      (str("outer") | str("outer-and-inner"))
                                    )
                                )
                            ),
                            a(str("inet6-precedence"), str("default"),
                                sc(
                                    b(str("protocol"),
                                      (str("mpls"))
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("loss-priority-rewrites"),
                        c(
                            b(str("frame-relay-de"),
                                c(
                                  (str("default") | arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("translation-table"),
                        c(
                            b(str("to-inet-precedence-from-inet-precedence"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("to-dscp-from-dscp"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("to-dscp-ipv6-from-dscp-ipv6"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("to-exp-from-exp"),
                                sc(
                                      arg
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("policy-map"),
                        sc(
                            arg
                        )
                    ).as(:oneline)
                )
            ),
            b(str("classifiers"),
                c(
                    a(str("dscp"), str("default")),
                    a(str("dscp-ipv6"), str("default")),
                    b(str("ieee-802.1"),
                        sc(
                              (str("default")),
                            b(str("vlan-tag"),
                              (str("outer") | str("inner"))
                            )
                        )
                    ).as(:oneline),
                    b(str("ieee-802.1ad"),
                        sc(
                              (str("default")),
                            b(str("vlan-tag"),
                              (str("outer") | str("inner"))
                            )
                        )
                    ).as(:oneline),
                    b(str("inet-precedence"),
                        c(
                          (str("default") | arg)
                        )
                    ).as(:oneline)
                )
            ),
            a(str("forwarding-class"), arg),
            b(str("rewrite-rules"),
                c(
                    a(str("dscp"), str("default")).as(:oneline),
                    a(str("dscp-ipv6"), str("default")).as(:oneline),
                    b(str("ieee-802.1"),
                        c(
                          (str("default") | arg)
                        )
                    ).as(:oneline),
                    b(str("ieee-802.1ad"),
                        c(
                              (str("default")),
                            b(str("vlan-tag"),
                              (str("outer"))
                            )
                        )
                    ),
                    a(str("inet-precedence"), str("default")).as(:oneline)
                )
            ),
            b(str("multi-destination"),
                c(
                    b(str("classifiers"),
                        c(
                            b(str("ieee-802.1"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("dscp"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("dscp-ipv6"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            b(str("inet-precedence"),
                                sc(
                                      arg
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("forwarding-class"), arg)
                )
            )
        )
      )
    end

    rule(:juniper_def_rtb_switch_options) do
        c(
            b(str("mac-table-size"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop"))
                    )
                )
            ),
            b(str("mac-ip-table-size"),
                c(
                      arg
                )
            ),
            b(str("interface-mac-limit"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                    )
                )
            ),
            b(str("interface-mac-ip-limit"),
                c(
                      arg
                )
            ),
            b(str("mac-notification"),
                c(
                    a(str("notification-interval"), arg)
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("no-normalization"),
            str("mac-statistics"),
            b(str("mib"),
                c(
                    b(str("dot1q-mib"),
                        c(
                            b(str("port-list"),
                              (str("bit-map") | str("string"))
                            )
                        )
                    )
                )
            ),
            b(str("static-rvtep-mac"),
                c(
                    b(str("mac"),
                        s(
                                arg,
                          a(str("remote-vtep"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            a(str("service-id"), arg),
            str("ovsdb-managed"),
            b(str("vtep-source-interface"),
                sc(
                      interface_name,
                    c(
                      str("inet6"),
                      str("inet")
                    )
                )
            ).as(:oneline),
            b(str("route-distinguisher"),
                sc(
                    arg
                )
            ).as(:oneline),
            b(str("vrf-import"),
              policy_algebra
            ),
            b(str("vrf-export"),
              policy_algebra
            ),
            b(str("vrf-target"),
                ca(
                    a(str("import"), arg),
                    a(str("export"), arg),
                    b(str("auto"),
                      juniper_def_rtb_auto_import_as
                    )
                )
            ),
            b(str("vtep-remote-interface"),
                c(
                    b(a(str("remote-ip"), arg),
                        c(
                            a(str("dynamic-profile"), arg)
                        )
                    ),
                    b(str("default"),
                        c(
                            a(str("dynamic-profile"), arg)
                        )
                    )
                )
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        ca(
                            str("disable"),
                            b(str("packet-action"),
                              (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                            )
                        )
                    ),
                    b(str("interface-mac-ip-limit"),
                        c(
                              arg
                        )
                    ),
                    str("no-mac-learning"),
                    str("mac-pinning"),
                    str("persistent-learning"),
                    str("no-mac-notification")
                )
            ),
            b(str("remote-vtep-list"),
              ipaddr
            ),
            b(str("interface-shutdown-action"),
              (str("soft-shutdown") | str("hard-shutdown"))
            ),
            b(str("remote-vtep-v6-list"),
              ipv6addr
            ),
            b(str("redundant-trunk-group"),
                c(
                    b(a(str("group"), arg),
                        c(
                            a(str("preempt-cutover-timer"), arg),
                            a(str("description"), quote | arg),
                            b(a(str("interface"), arg),
                                c(
                                    str("primary")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("voip"),
                c(
                    a(str("interface"), str("access-ports") | arg,
                        c(
                            a(str("vlan"), arg),
                            a(str("forwarding-class"), arg)
                        )
                    )
                )
            ),
            b(str("unknown-unicast-forwarding"),
                c(
                    b(a(str("vlan"), arg),
                        c(
                            b(str("interface"),
                              interface_name
                            )
                        )
                    )
                )
            ),
            b(a(str("authentication-whitelist"), arg),
                c(
                    a(str("vlan-assignment"), arg),
                    a(str("bridge-domain-assignment"), arg),
                    b(str("interface"),
                      interface_name
                    )
                )
            )
        )
    end

    rule(:juniper_def_rtb_auto_import_as) do
        c(
            b(a(str("import-as"), arg),
                c(
                    a(str("vni-list"), arg)
                )
            )
        )
    end

    rule(:juniper_dynamic_profile_object) do
      b(arg.as(:arg),
        c(
            b(str("variables"),
              juniper_dynamic_variable_object
            ),
            b(str("predefined-variable-defaults"),
                c(
                    b(str("aggregation-interface-set-name"),
                        c(
                            ca(
                              a(str("equals"), arg)
                            )
                        )
                    ),
                    b(str("interface-set-name"),
                        c(
                            ca(
                              a(str("equals"), arg)
                            )
                        )
                    ),
                    b(str("default-interface-set-name"),
                        c(
                            a(str("equals"), arg)
                        )
                    ),
                    b(str("phy-ifd-interface-set-name"),
                        c(
                            ca(
                              a(str("equals"), arg)
                            )
                        )
                    ),
                    b(str("phy-ifd-underlying-intf-set-name"),
                        c(
                            ca(
                              a(str("equals"), arg)
                            )
                        )
                    ),
                    b(str("cos-excess-rate"),
                        c(
                            a(str("proportion"), arg),
                            a(str("percent"), arg)
                        )
                    ),
                    b(str("cos-excess-rate-high"),
                        c(
                            a(str("proportion"), arg),
                            a(str("percent"), arg)
                        )
                    ),
                    b(str("cos-excess-rate-low"),
                        c(
                            a(str("proportion"), arg),
                            a(str("percent"), arg)
                        )
                    ),
                    b(str("cos-scheduler-tx"),
                        c(
                            a(str("rate"), arg),
                            a(str("percent"), arg)
                        )
                    ),
                    b(str("cos-scheduler-bs"),
                        c(
                            a(str("percent"), arg),
                            a(str("temporal"), arg)
                        )
                    ),
                    b(str("cos-scheduler-shaping-rate"),
                        c(
                            a(str("rate"), arg),
                            a(str("percent"), arg)
                        )
                    ),
                      base_default_variable_object
                )
            ),
            b(str("routing-instances"),
                c(
                        c(
                            a(str("interface"), arg | arg,
                                c(
                                    c(
                                      str("any"),
                                      str("unicast"),
                                      str("multicast")
                                    ),
                                    str("primary"),
                                    b(str("protect-interface"),
                                      interface_name
                                    )
                                )
                            ),
                            b(str("routing-options"),
                                c(
                                    b(a(str("rib"), arg),
                                        c(
                                            b(str("static"),
                                                c(
                                                    b(a(str("route"), arg),
                                                        c(
                                                            c(
                                                              b(str("next-hop"),
                                                                ipaddr_or_interface
                                                              ),
                                                              str("reject"),
                                                              str("discard"),
                                                              str("receive"),
                                                              a(str("next-table"), arg)
                                                            ),
                                                            b(str("qualified-next-hop"),
                                                              qualified_nh_obj
                                                            ),
                                                            a(str("backup-pe-group"), arg),
                                                            b(str("bfd-liveness-detection"),
                                                                c(
                                                                    b(str("version"),
                                                                      (str("0") | str("1") | str("automatic"))
                                                                    ),
                                                                    a(str("minimum-interval"), arg),
                                                                    a(str("minimum-transmit-interval"), arg),
                                                                    a(str("minimum-receive-interval"), arg),
                                                                    a(str("multiplier"), arg),
                                                                    c(
                                                                      str("no-adaptation")
                                                                    ),
                                                                    b(str("transmit-interval"),
                                                                        c(
                                                                            a(str("minimum-interval"), arg),
                                                                            a(str("threshold"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("detection-time"),
                                                                        c(
                                                                            a(str("threshold"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("authentication"),
                                                                        c(
                                                                            a(str("key-chain"), arg),
                                                                            b(str("algorithm"),
                                                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                                            ),
                                                                            str("loose-check")
                                                                        )
                                                                    ),
                                                                    b(str("neighbor"),
                                                                      ipaddr
                                                                    ),
                                                                    b(str("local-address"),
                                                                      ipaddr
                                                                    ),
                                                                    a(str("holddown-interval"), arg),
                                                                    a(str("minimum-receive-ttl"), arg)
                                                                )
                                                            ),
                                                            str("retain"),
                                                            str("no-retain"),
                                                            str("install"),
                                                            str("no-install"),
                                                            str("readvertise"),
                                                            str("no-readvertise"),
                                                            str("resolve"),
                                                            str("no-resolve"),
                                                            str("longest-match"),
                                                            str("no-longest-match"),
                                                            c(
                                                              str("active"),
                                                              str("passive")
                                                            ),
                                                            b(str("metric"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric3"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric4"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("tag"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("tag2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("preference"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("preference2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("color"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("color2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("community"),
                                                              community
                                                            ),
                                                            b(str("as-path"),
                                                              c(
                                                                a(str("path"), quote | arg),
                                                                    b(str("origin"),
                                                                      (str("igp") | str("egp") | str("incomplete"))
                                                                    ),
                                                                    str("atomic-aggregate"),
                                                                    b(str("aggregator"),
                                                                        ca(
                                                                              ipv4addr
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            b(str("lsp-next-hop"),
                                                              lsp_nh_obj
                                                            ),
                                                            b(str("static-lsp-next-hop"),
                                                              lsp_nh_obj
                                                            ),
                                                            b(str("p2mp-lsp-next-hop"),
                                                              lsp_nh_obj
                                                            ),
                                                            b(str("p2mp-ldp-next-hop"),
                                                              p2mp_ldp_lsp_nh_obj
                                                            )
                                                        )
                                                    ),
                                                    b(a(str("iso-route"), arg),
                                                        c(
                                                            c(
                                                              b(str("next-hop"),
                                                                ipaddr_or_interface
                                                              ),
                                                              str("reject"),
                                                              str("discard"),
                                                              str("receive"),
                                                              a(str("next-table"), arg)
                                                            ),
                                                            b(str("qualified-next-hop"),
                                                              qualified_nh_obj
                                                            ),
                                                            a(str("backup-pe-group"), arg),
                                                            b(str("bfd-liveness-detection"),
                                                                c(
                                                                    b(str("version"),
                                                                      (str("0") | str("1") | str("automatic"))
                                                                    ),
                                                                    a(str("minimum-interval"), arg),
                                                                    a(str("minimum-transmit-interval"), arg),
                                                                    a(str("minimum-receive-interval"), arg),
                                                                    a(str("multiplier"), arg),
                                                                    c(
                                                                      str("no-adaptation")
                                                                    ),
                                                                    b(str("transmit-interval"),
                                                                        c(
                                                                            a(str("minimum-interval"), arg),
                                                                            a(str("threshold"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("detection-time"),
                                                                        c(
                                                                            a(str("threshold"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("authentication"),
                                                                        c(
                                                                            a(str("key-chain"), arg),
                                                                            b(str("algorithm"),
                                                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                                            ),
                                                                            str("loose-check")
                                                                        )
                                                                    ),
                                                                    b(str("neighbor"),
                                                                      ipaddr
                                                                    ),
                                                                    b(str("local-address"),
                                                                      ipaddr
                                                                    ),
                                                                    a(str("holddown-interval"), arg),
                                                                    a(str("minimum-receive-ttl"), arg)
                                                                )
                                                            ),
                                                            str("retain"),
                                                            str("no-retain"),
                                                            str("install"),
                                                            str("no-install"),
                                                            str("readvertise"),
                                                            str("no-readvertise"),
                                                            str("resolve"),
                                                            str("no-resolve"),
                                                            str("longest-match"),
                                                            str("no-longest-match"),
                                                            c(
                                                              str("active"),
                                                              str("passive")
                                                            ),
                                                            b(str("metric"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric3"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric4"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("tag"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("tag2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("preference"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("preference2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("color"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("color2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("community"),
                                                              community
                                                            ),
                                                            b(str("as-path"),
                                                              c(
                                                                a(str("path"), quote | arg),
                                                                    b(str("origin"),
                                                                      (str("igp") | str("egp") | str("incomplete"))
                                                                    ),
                                                                    str("atomic-aggregate"),
                                                                    b(str("aggregator"),
                                                                        ca(
                                                                              ipv4addr
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            b(str("lsp-next-hop"),
                                                              lsp_nh_obj
                                                            ),
                                                            b(str("static-lsp-next-hop"),
                                                              lsp_nh_obj
                                                            ),
                                                            b(str("p2mp-lsp-next-hop"),
                                                              lsp_nh_obj
                                                            ),
                                                            b(str("p2mp-ldp-next-hop"),
                                                              p2mp_ldp_lsp_nh_obj
                                                            )
                                                        )
                                                    ),
                                                    a(str("rib-group"), arg),
                                                    b(str("defaults"),
                                                        c(
                                                            str("retain"),
                                                            str("no-retain"),
                                                            str("install"),
                                                            str("no-install"),
                                                            str("readvertise"),
                                                            str("no-readvertise"),
                                                            str("resolve"),
                                                            str("no-resolve"),
                                                            str("longest-match"),
                                                            str("no-longest-match"),
                                                            c(
                                                              str("active"),
                                                              str("passive")
                                                            ),
                                                            b(str("metric"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric3"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric4"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("tag"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("tag2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("preference"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("preference2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("color"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("color2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("community"),
                                                              community
                                                            ),
                                                            b(str("as-path"),
                                                              c(
                                                                a(str("path"), quote | arg),
                                                                    b(str("origin"),
                                                                      (str("igp") | str("egp") | str("incomplete"))
                                                                    ),
                                                                    str("atomic-aggregate"),
                                                                    b(str("aggregator"),
                                                                        ca(
                                                                              ipv4addr
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("static-route"),
                                                        sc(
                                                            b(str("bfd-admin-down"),
                                                              (str("active") | str("passive"))
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    b(a(str("route-target-filter"), arg),
                                                        c(
                                                            b(str("neighbor"),
                                                              ipaddr
                                                            ),
                                                            a(str("group"), arg),
                                                            str("local")
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("martians"),
                                              martian_type
                                            ),
                                            b(str("aggregate"),
                                              rib_aggregate_type
                                            ),
                                            b(str("generate"),
                                              rib_aggregate_type
                                            ),
                                            c(
                                              b(str("maximum-routes"),
                                                  sc(
                                                        arg,
                                                      c(
                                                        a(str("threshold"), arg),
                                                        str("log-only")
                                                      ),
                                                      a(str("log-interval"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("maximum-paths"),
                                                  sc(
                                                        arg,
                                                      c(
                                                        a(str("threshold"), arg),
                                                        str("log-only")
                                                      ),
                                                      a(str("log-interval"), arg)
                                                  )
                                              ).as(:oneline)
                                            ),
                                            b(str("maximum-prefixes"),
                                                sc(
                                                      arg,
                                                    c(
                                                      a(str("threshold"), arg),
                                                      str("log-only")
                                                    ),
                                                    a(str("log-interval"), arg)
                                                )
                                            ).as(:oneline),
                                            b(str("multipath"),
                                                c(
                                                    b(str("vpn-unequal-cost"),
                                                        sc(
                                                            str("equal-external-internal")
                                                        )
                                                    ).as(:oneline),
                                                    str("as-path-compare"),
                                                    str("preserve-nexthop-hierarchy")
                                                )
                                            ),
                                            b(str("policy-multipath"),
                                                c(
                                                    b(str("policy"),
                                                      policy_algebra
                                                    ),
                                                    b(str("traceoptions"),
                                                        c(
                                                            b(str("file"),
                                                                sc(
                                                                      arg,
                                                                    str("replace"),
                                                                    a(str("size"), arg),
                                                                    a(str("files"), arg),
                                                                    str("no-stamp"),
                                                                    str("world-readable"),
                                                                    str("no-world-readable")
                                                                )
                                                            ).as(:oneline),
                                                            a(str("flag"), enum(str("route")),
                                                                sc(
                                                                    str("send"),
                                                                    str("receive"),
                                                                    str("detail"),
                                                                    str("disable")
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("protect"),
                                                sc(
                                                    str("core")
                                                )
                                            ).as(:oneline),
                                            b(str("access"),
                                                c(
                                                    b(a(str("route"), arg),
                                                        c(
                                                            b(str("next-hop"),
                                                              ipaddr_or_interface
                                                            ),
                                                            b(str("qualified-next-hop"),
                                                              qualified_nh_obj
                                                            ),
                                                            a(str("metric"), arg),
                                                            a(str("preference"), arg),
                                                            a(str("tag"), arg),
                                                            a(str("tag2"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("access-internal"),
                                                c(
                                                    b(a(str("route"), arg),
                                                        c(
                                                            b(str("next-hop"),
                                                              ipaddr_or_interface
                                                            ),
                                                            b(str("qualified-next-hop"),
                                                              qualified_nh_obj
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("bgp-static"),
                                                c(
                                                    b(a(str("route"), arg),
                                                        c(
                                                            b(str("metric"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric3"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("metric4"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("tag"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("tag2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("preference"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("preference2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("color"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("color2"),
                                                              rib_static_metric_type
                                                            ),
                                                            b(str("community"),
                                                              community
                                                            ),
                                                            b(str("as-path"),
                                                              c(
                                                                a(str("path"), quote | arg),
                                                                    b(str("origin"),
                                                                      (str("igp") | str("egp") | str("incomplete"))
                                                                    ),
                                                                    str("atomic-aggregate"),
                                                                    b(str("aggregator"),
                                                                        ca(
                                                                              ipv4addr
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("flow"),
                                                c(
                                                    b(str("validation"),
                                                      flow_validation
                                                    ),
                                                    b(str("route"),
                                                      flow_route_inet6
                                                    ),
                                                    b(str("interface-group"),
                                                      flow_interface_group
                                                    ),
                                                    str("discard-action-for-unresolved-redir-addr")
                                                )
                                            ),
                                            b(str("label"),
                                                c(
                                                    b(str("allocation"),
                                                      policy_algebra
                                                    ),
                                                    b(str("substitution"),
                                                      policy_algebra
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("access"),
                                        c(
                                            b(a(str("route"), arg),
                                                c(
                                                    b(str("next-hop"),
                                                      ipaddr_or_interface
                                                    ),
                                                    b(str("qualified-next-hop"),
                                                      qualified_nh_obj
                                                    ),
                                                    a(str("metric"), arg),
                                                    a(str("preference"), arg),
                                                    a(str("tag"), arg),
                                                    a(str("tag2"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("access-internal"),
                                        c(
                                            b(a(str("route"), arg),
                                                c(
                                                    b(str("next-hop"),
                                                      ipaddr_or_interface
                                                    ),
                                                    b(str("qualified-next-hop"),
                                                      qualified_nh_obj
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("multicast"),
                                        c(
                                            b(str("traceoptions"),
                                                c(
                                                    b(str("file"),
                                                        sc(
                                                              arg,
                                                            str("replace"),
                                                            a(str("size"), arg),
                                                            a(str("files"), arg),
                                                            str("no-stamp"),
                                                            str("world-readable"),
                                                            str("no-world-readable")
                                                        )
                                                    ).as(:oneline),
                                                    a(str("flag"), enum(str("parse") | str("config-internal") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                                        sc(
                                                            str("disable")
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("rpf"), arg),
                                            b(a(str("scope"), arg),
                                                c(
                                                    b(str("prefix"),
                                                      ipprefix
                                                    ),
                                                    b(str("interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("scope-policy"),
                                              policy_algebra
                                            ),
                                            b(a(str("flow-map"), arg),
                                                c(
                                                    b(str("policy"),
                                                      policy_algebra
                                                    ),
                                                    b(str("bandwidth"),
                                                        sc(
                                                            arg,
                                                            str("adaptive")
                                                        )
                                                    ).as(:oneline),
                                                    b(str("redundant-sources"),
                                                      ipaddr
                                                    ),
                                                    b(str("forwarding-cache"),
                                                        c(
                                                            b(str("timeout"),
                                                                sc(
                                                                    ca(
                                                                      b(str("never"),
                                                                          c(
                                                                              str("non-discard-entry-only")
                                                                          )
                                                                      )
                                                                    )
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("resolve-filter"),
                                              policy_algebra
                                            ),
                                            b(str("ssm-groups"),
                                              ipprefix
                                            ),
                                            str("asm-override-ssm"),
                                            b(str("rpf-check-policy"),
                                              policy_algebra
                                            ),
                                            b(str("pim-to-igmp-proxy"),
                                                c(
                                                    b(str("upstream-interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("pim-to-mld-proxy"),
                                                c(
                                                    b(str("upstream-interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("forwarding-cache"),
                                                c(
                                                    str("allow-maximum"),
                                                    a(str("family"), enum(str("inet6") | str("inet")),
                                                        c(
                                                            b(str("threshold"),
                                                                c(
                                                                    a(str("suppress"), arg),
                                                                    a(str("reuse"), arg),
                                                                    a(str("mvpn-rpt-suppress"), arg),
                                                                    a(str("mvpn-rpt-reuse"), arg),
                                                                    a(str("log-warning"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("threshold"),
                                                        c(
                                                            a(str("suppress"), arg),
                                                            a(str("reuse"), arg),
                                                            a(str("mvpn-rpt-suppress"), arg),
                                                            a(str("mvpn-rpt-reuse"), arg),
                                                            a(str("log-warning"), arg)
                                                        )
                                                    ),
                                                    a(str("timeout"), arg)
                                                )
                                            ),
                                            b(str("interface"),
                                              multicast_interface_options_type
                                            ),
                                            b(a(str("ssm-map"), arg),
                                                c(
                                                    b(str("policy"),
                                                      policy_algebra
                                                    ),
                                                    b(str("source"),
                                                      ipaddr
                                                    )
                                                )
                                            ),
                                            b(str("stream-protection"),
                                                c(
                                                    str("mofrr-primary-path-selection-by-routing"),
                                                    str("mofrr-disjoint-upstream-only"),
                                                    str("mofrr-no-backup-join"),
                                                    str("mofrr-asm-starg"),
                                                    b(str("policy"),
                                                      policy_algebra
                                                    )
                                                )
                                            ),
                                            b(a(str("backup-pe-group"), arg),
                                                c(
                                                    b(str("backups"),
                                                      ipaddr
                                                    ),
                                                    b(str("local-address"),
                                                      ipaddr
                                                    )
                                                )
                                            ),
                                            str("omit-wildcard-address"),
                                            b(str("local-address"),
                                              ipv4addr
                                            )
                                        )
                                    )
                                )
                            )
                        )
                )
            ),
            b(str("telemetry"),
                c(
                    str("service-statistics"),
                    str("subscriber-statistics"),
                    b(str("queue-statistics"),
                        c(
                            a(str("interface"), arg,
                                c(
                                    a(str("refresh"), arg),
                                    a(str("queues"), arg)
                                )
                            ),
                            a(str("interface-set"), arg,
                                c(
                                    a(str("refresh"), arg),
                                    a(str("queues"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("interfaces"),
                c(
                    b(a(str("pic-set"), arg),
                        c(
                            a(str("interface"), arg),
                            b(a(str("fpc"), arg),
                                c(
                                    a(str("pic"), arg)
                                )
                            )
                        )
                    ),
                    a(str("interface-set"), arg | arg | arg | arg | arg | arg,
                        c(
                            str("targeted-distribution"),
                            b(str("targeted-options"),
                                c(
                                    b(str("weight"),
                                      (arg | arg)
                                    )
                                )
                            ),
                            b(a(str("interface"), arg),
                                c(
                                    a(str("unit"), arg),
                                    a(str("vlan-tags-outer"), arg)
                                )
                            ),
                            b(str("pppoe-underlying-options"),
                              pppoe_underlying_options_type
                            )
                        )
                    ),
                    b(str("stacked-interface-set"),
                        c(
                            a(str("interface-set"), arg | arg,
                                c(
                                    a(str("interface-set"), arg | arg | arg | arg | arg | arg)
                                )
                            )
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("all") | str("kernel") | str("change-events") | str("kernel-detail") | str("config-states") | str("resource-usage") | str("gres-events") | str("select-events") | str("bfd-events") | str("lib-events") | str("reserved") | str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("informational") | str("debugging") | str("verbose") | str("japi")),
                                sc(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("interface-range"), arg),
                        c(
                            a(str("member"), arg),
                            b(a(str("member-range"), arg),
                                sc(
                                    b(str("end-range"),
                                      interface_device
                                    )
                                )
                            ).as(:oneline),
                            a(str("description"), quote | arg),
                            a(str("external-model-name"), arg),
                            a(str("metadata"), arg),
                              (str("disable")),
                            str("promiscuous-mode"),
                            a(str("port-mirror-instance"), arg),
                            str("multicast-statistics"),
                            str("oam-on-svlan"),
                            b(str("fabric-options"),
                                c(
                                    a(str("member-interfaces"), arg),
                                    b(str("remote-chassis"),
                                        c(
                                            b(str("destination"),
                                              ipv4addr
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    a(str("flag"), enum(str("ipc") | str("event") | str("media") | str("all"))).as(:oneline)
                                )
                            ),
                            str("passive-monitor-mode"),
                            c(
                              b(str("keepalives"),
                                keepalives_type
                              ).as(:oneline),
                              str("no-keepalives")
                            ),
                            str("traps"),
                            str("no-traps"),
                            str("interface-mib"),
                            str("no-interface-mib"),
                            a(str("accounting-profile"), arg),
                            b(str("anchor-point"),
                                c(
                                      interface_device
                                )
                            ),
                            str("bypass-queueing-chip"),
                            str("no-bypass-queueing-chip"),
                            c(
                              str("per-unit-scheduler"),
                              str("no-per-unit-scheduler"),
                              str("shared-scheduler"),
                              b(str("hierarchical-scheduler"),
                                  sc(
                                      a(str("maximum-hierarchy-levels"), arg),
                                      a(str("maximum-l2-nodes"), arg),
                                      a(str("maximum-l3-nodes"), arg),
                                      str("implicit-hierarchy")
                                  )
                              ).as(:oneline)
                            ),
                            a(str("l2tp-maximum-session"), arg),
                            a(str("schedulers"), arg),
                            str("interface-transmit-statistics"),
                            str("cascade-port"),
                            str("dce"),
                            c(
                              str("vlan-tagging"),
                              str("stacked-vlan-tagging"),
                              str("flexible-vlan-tagging"),
                              str("vlan-vci-tagging")
                            ),
                            str("hybrid-access"),
                            a(str("native-vlan-id"), arg),
                            str("no-native-vlan-insert"),
                            str("vlan-offload"),
                            b(str("input-native-vlan-push"),
                              (str("disable") | str("enable"))
                            ),
                            str("no-pseudowire-down-on-core-isolation"),
                            b(str("speed"),
                              (str("auto") | str("auto-10m-100m") | str("10m") | str("100m") | str("1g") | str("2.5g") | str("5g") | str("10g") | str("40g") | str("oc3") | str("oc12") | str("oc48"))
                            ),
                            b(str("forwarding-class-accounting"),
                                c(
                                    b(str("direction"),
                                      (str("ingress") | str("egress") | str("both"))
                                    ),
                                    b(str("enhanced"),
                                        c(
                                            b(str("traffic-type"),
                                              (str("unicast-statistics") | str("multicast-statistics"))
                                            ),
                                            b(str("family"),
                                              (str("inet6") | str("inet") | str("both"))
                                            ),
                                            b(str("direction"),
                                              (str("ingress") | str("egress") | str("both"))
                                            ),
                                            a(str("overhead-bytes"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("auto-configure"),
                              auto_configure_vlan_type
                            ),
                            a(str("mtu"), arg),
                            b(str("hold-time"),
                                sc(
                                    a(str("up"), arg),
                                    a(str("down"), arg)
                                )
                            ).as(:oneline),
                            b(str("damping"),
                                c(
                                    a(str("half-life"), arg),
                                    a(str("max-suppress"), arg),
                                    a(str("reuse"), arg),
                                    a(str("suppress"), arg),
                                    str("enable")
                                )
                            ),
                            b(str("link-degrade-monitor"),
                                c(
                                    b(str("actions"),
                                        c(
                                            c(
                                              str("media-based")
                                            )
                                        )
                                    ),
                                    b(str("recovery"),
                                        c(
                                            a(str("timer"), arg),
                                            c(
                                              str("auto"),
                                              str("manual")
                                            )
                                        )
                                    ),
                                    b(str("thresholds"),
                                        c(
                                            a(str("set"), arg),
                                            a(str("clear"), arg),
                                            a(str("warning-set"), arg),
                                            a(str("warning-clear"), arg),
                                            a(str("interval"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("satop-options"),
                                c(
                                    a(str("idle-pattern"), arg),
                                    a(str("payload-size"), arg),
                                    b(str("excessive-packet-loss-rate"),
                                        c(
                                            a(str("threshold"), arg),
                                            a(str("sample-period"), arg)
                                        )
                                    ),
                                    c(
                                      a(str("jitter-buffer-packets"), arg),
                                      a(str("jitter-buffer-latency"), arg),
                                      str("jitter-buffer-auto-adjust")
                                    ),
                                    a(str("bit-rate"), arg)
                                )
                            ),
                            b(str("cesopsn-options"),
                                c(
                                    a(str("idle-pattern"), arg),
                                    a(str("packetization-latency"), arg),
                                    a(str("payload-size"), arg),
                                    b(str("excessive-packet-loss-rate"),
                                        c(
                                            a(str("threshold"), arg),
                                            a(str("sample-period"), arg)
                                        )
                                    ),
                                    c(
                                      a(str("jitter-buffer-packets"), arg),
                                      a(str("jitter-buffer-latency"), arg),
                                      str("jitter-buffer-auto-adjust")
                                    ),
                                    a(str("bit-rate"), arg)
                                )
                            ),
                            b(str("ima-group-options"),
                                c(
                                    b(str("frame-length"),
                                      (str("32") | str("64") | str("128") | str("256"))
                                    ),
                                    b(str("symmetry"),
                                      (str("symmetrical-config-and-operation") | str("symmetrical-config-asymmetrical-operation"))
                                    ),
                                    b(str("transmit-clock"),
                                      (str("common") | str("independent"))
                                    ),
                                    b(str("version"),
                                      (str("1.0") | str("1.1"))
                                    ),
                                    b(str("minimum-links"),
                                        c(
                                            c(
                                                arg
                                            )
                                        )
                                    ),
                                    b(str("frame-synchronization"),
                                        c(
                                            a(str("alpha"), arg),
                                            a(str("beta"), arg),
                                            a(str("gamma"), arg)
                                        )
                                    ),
                                    b(str("test-procedure"),
                                        c(
                                            a(str("period"), arg),
                                            b(str("interface"),
                                              interface_device
                                            ),
                                            a(str("pattern"), arg)
                                        )
                                    ),
                                    a(str("differential-delay"), arg)
                                )
                            ),
                            b(str("ima-link-options"),
                                c(
                                    a(str("group-id"), arg)
                                )
                            ),
                            b(str("multi-chassis-protection"),
                              multi_chassis_protection_group
                            ),
                            b(str("clocking"),
                                sc(
                                    c(
                                      str("internal"),
                                      str("external")
                                    )
                                )
                            ).as(:oneline),
                            b(str("link-mode"),
                              (str("automatic") | str("half-duplex") | str("full-duplex"))
                            ),
                            b(str("media-type"),
                              (str("copper") | str("fiber"))
                            ),
                            b(str("encapsulation"),
                              (str("ethernet-ccc") | str("fddi") | str("token-ring") | str("ppp") | str("ppp-ccc") | str("ppp-tcc") | str("ether-vpls-ppp") | str("frame-relay") | str("frame-relay-ccc") | str("frame-relay-tcc") | str("extended-frame-relay-ccc") | str("extended-frame-relay-tcc") | str("flexible-frame-relay") | str("frame-relay-port-ccc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("extended-frame-relay-ether-type-tcc") | str("cisco-hdlc") | str("cisco-hdlc-ccc") | str("cisco-hdlc-tcc") | str("vlan-ccc") | str("extended-vlan-ccc") | str("ethernet-tcc") | str("flexible-ethernet-services") | str("smds-dxi") | str("atm-pvc") | str("atm-ccc-cell-relay") | str("ethernet-over-atm") | str("ethernet-vpls") | str("extended-vlan-tcc") | str("multilink-frame-relay-uni-nni") | str("satop") | str("cesopsn") | str("ima") | str("ethernet-bridge") | str("ethernet") | str("vlan-vpls") | str("vlan-vci-ccc") | str("extended-vlan-vpls") | str("extended-vlan-bridge") | str("multilink-ppp") | str("generic-services"))
                            ),
                            b(str("esi"),
                                c(
                                    b(str("auto-derive"),
                                        c(
                                            c(
                                              str("lacp")
                                            )
                                        )
                                    ),
                                      esi,
                                    c(
                                      str("single-active"),
                                      str("all-active")
                                    ),
                                    b(str("df-election-type"),
                                        c(
                                            c(
                                              b(str("preference"),
                                                  c(
                                                      a(str("value"), arg)
                                                  )
                                              )
                                            ),
                                            c(
                                              str("mod")
                                            )
                                        )
                                    ),
                                    b(str("source-bmac"),
                                      mac_unicast
                                    )
                                )
                            ),
                            b(str("framing"),
                                c(
                                    c(
                                      str("lan-phy"),
                                      str("wan-phy"),
                                      str("sonet"),
                                      str("sdh")
                                    ),
                                    str("precise-bandwidth")
                                )
                            ),
                            str("unidirectional"),
                            b(str("lmi"),
                                c(
                                    a(str("n391dte"), arg),
                                    a(str("n392dce"), arg),
                                    a(str("n392dte"), arg),
                                    a(str("n393dce"), arg),
                                    a(str("n393dte"), arg),
                                    a(str("t391dte"), arg),
                                    a(str("t392dce"), arg),
                                    b(str("lmi-type"),
                                      (str("ansi") | str("itu") | str("c-lmi"))
                                    )
                                )
                            ),
                            b(str("mlfr-uni-nni-bundle-options"),
                                c(
                                    b(str("cisco-interoperability"),
                                        c(
                                            str("send-lip-remove-link-for-link-reject")
                                        )
                                    ),
                                    a(str("mrru"), arg),
                                    a(str("yellow-differential-delay"), arg),
                                    a(str("red-differential-delay"), arg),
                                    b(str("action-red-differential-delay"),
                                      (str("remove-link") | str("disable-tx"))
                                    ),
                                    a(str("fragment-threshold"), arg),
                                    a(str("drop-timeout"), arg),
                                    b(str("link-layer-overhead"),
                                      unsigned_float
                                    ),
                                    b(str("lmi-type"),
                                      (str("ansi") | str("itu") | str("c-lmi"))
                                    ),
                                    a(str("minimum-links"), arg),
                                    a(str("hello-timer"), arg),
                                    a(str("acknowledge-timer"), arg),
                                    a(str("acknowledge-retries"), arg),
                                    a(str("n391"), arg),
                                    a(str("n392"), arg),
                                    a(str("n393"), arg),
                                    a(str("t391"), arg),
                                    a(str("t392"), arg)
                                )
                            ),
                            b(str("mac"),
                              mac_unicast
                            ),
                            b(str("receive-bucket"),
                              dcd_rx_bucket_config
                            ),
                            b(str("transmit-bucket"),
                              dcd_tx_bucket_config
                            ),
                            str("shared-interface"),
                            b(str("sonet-options"),
                              sonet_options_type
                            ),
                            b(str("logical-tunnel-options"),
                                c(
                                    b(str("link-protection"),
                                        c(
                                            str("revertive"),
                                            str("non-revertive")
                                        )
                                    ),
                                    str("per-unit-mac-disable"),
                                    b(str("load-balance"),
                                      aggregate_load_balance
                                    )
                                )
                            ),
                            b(str("aggregated-sonet-options"),
                                c(
                                    a(str("minimum-links"), arg),
                                    b(str("link-speed"),
                                      (str("oc3") | str("oc12") | str("oc48") | str("oc192") | str("oc768") | str("mixed"))
                                    ),
                                    a(str("minimum-bandwidth"), arg)
                                )
                            ),
                            b(str("atm-options"),
                                c(
                                    b(str("pic-type"),
                                      (str("atm-ce") | str("atm2") | str("atm1"))
                                    ),
                                    a(str("cell-bundle-size"), arg),
                                    a(str("cell-bundle-timeout"), arg),
                                    str("plp-to-clp"),
                                    str("use-null-cw"),
                                    b(str("promiscuous-mode"),
                                        c(
                                            a(str("vpi"), arg).as(:oneline)
                                        )
                                    ),
                                    b(a(str("vpi"), arg),
                                        c(
                                            a(str("maximum-vcs"), arg),
                                            b(str("shaping"),
                                              dcd_shaping_config
                                            ),
                                            b(str("oam-period"),
                                                sc(
                                                    ca(
                                                      str("disable").as(:oneline)
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("oam-liveness"),
                                                c(
                                                    a(str("up-count"), arg),
                                                    a(str("down-count"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    str("ilmi"),
                                    b(a(str("linear-red-profiles"), arg),
                                        sc(
                                            a(str("queue-depth"), arg),
                                            a(str("high-plp-threshold"), arg),
                                            a(str("low-plp-threshold"), arg),
                                            a(str("high-plp-max-threshold"), arg),
                                            a(str("low-plp-max-threshold"), arg)
                                        )
                                    ).as(:oneline),
                                    b(a(str("scheduler-maps"), arg),
                                        c(
                                            b(str("vc-cos-mode"),
                                              (str("strict") | str("alternate"))
                                            ),
                                            b(a(str("forwarding-class"), arg),
                                                c(
                                                    b(str("priority"),
                                                      (str("low") | str("high"))
                                                    ),
                                                    b(str("transmit-weight"),
                                                        sc(
                                                            c(
                                                              a(str("percent"), arg),
                                                              a(str("cells"), arg)
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    c(
                                                      b(str("epd-threshold"),
                                                        epd_threshold_config
                                                      ).as(:oneline),
                                                      a(str("linear-red-profile"), arg)
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("mpls"),
                                      mpls_ifd_options
                                    ),
                                    str("payload-scrambler"),
                                    str("no-payload-scrambler")
                                )
                            ),
                            b(str("multiservice-options"),
                                c(
                                    str("syslog"),
                                    str("no-syslog"),
                                    str("core-dump"),
                                    str("no-core-dump"),
                                    str("dump-on-flow-control"),
                                    str("no-dump-on-flow-control"),
                                    str("reset-on-flow-control"),
                                    str("no-reset-on-flow-control"),
                                    b(str("flow-control-options"),
                                        c(
                                            str("dump-on-flow-control"),
                                            str("reset-on-flow-control"),
                                            str("down-on-flow-control"),
                                            str("up-on-flow-control")
                                        )
                                    )
                                )
                            ),
                            b(str("ggsn-options"),
                                c(
                                    str("syslog"),
                                    str("no-syslog"),
                                    str("core-dump"),
                                    str("no-core-dump")
                                )
                            ),
                            b(str("ppp-options"),
                              ppp_options_type
                            ),
                            b(str("redundancy-options"),
                                c(
                                    b(str("primary"),
                                      interface_device
                                    ),
                                    b(str("secondary"),
                                      interface_device
                                    ),
                                    b(str("redundancy-peer"),
                                        c(
                                            b(str("ipaddress"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("redundancy-local"),
                                        c(
                                            b(str("data-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    a(str("routing-instance"), arg),
                                    a(str("replication-threshold"), arg),
                                    b(str("replication-options"),
                                        c(
                                            a(str("mtu"), arg)
                                        )
                                    ),
                                    b(str("replicate-services"),
                                        c(
                                            str("pgcp")
                                        )
                                    )
                                )
                            ),
                            b(str("load-balancing-options"),
                                c(
                                    a(str("member-interface"), arg),
                                    b(str("member-failure-options"),
                                        c(
                                            c(
                                              b(str("redistribute-all-traffic"),
                                                  c(
                                                      str("enable-rejoin")
                                                  )
                                              ),
                                              b(str("drop-member-traffic"),
                                                  c(
                                                      a(str("rejoin-timeout"), arg),
                                                      str("enable-rejoin")
                                                  )
                                              )
                                            )
                                        )
                                    ),
                                    b(str("high-availability-options"),
                                        c(
                                            c(
                                              b(str("many-to-one"),
                                                  c(
                                                      b(str("preferred-backup"),
                                                        interface_device
                                                      )
                                                  )
                                              ),
                                              b(str("one-to-one"),
                                                  c(
                                                      b(str("preferred-backup"),
                                                        interface_device
                                                      )
                                                  )
                                              )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("aggregated-inline-services-options"),
                                c(
                                    b(str("primary-interface"),
                                      interface_device
                                    ),
                                    b(str("secondary-interface"),
                                      interface_device
                                    )
                                )
                            ),
                            b(str("anchoring-options"),
                                c(
                                    a(str("apfe-group-set"), arg),
                                    a(str("primary-list"), arg),
                                    b(str("secondary"),
                                        c(
                                            arg
                                        )
                                    ),
                                    c(
                                      str("warm-standby")
                                    )
                                )
                            ),
                            b(str("lsq-failure-options"),
                                c(
                                    a(str("trigger-link-failure"), arg),
                                    str("no-termination-request"),
                                    str("no-no-termination-request")
                                )
                            ),
                            b(str("redundancy-group"),
                                c(
                                    b(a(str("member-interface"), arg),
                                        c(
                                            c(
                                              str("active"),
                                              str("backup")
                                            )
                                        )
                                    ),
                                    a(str("maximum-links"), arg)
                                )
                            ),
                            b(str("services-options"),
                                c(
                                    b(str("syslog"),
                                      log_object
                                    ),
                                    b(str("jflow-log"),
                                        c(
                                            a(str("message-rate-limit"), arg)
                                        )
                                    ),
                                    b(str("deterministic-nat-configuration-log-interval"),
                                        c(
                                            a(str("interval"), arg)
                                        )
                                    ),
                                    a(str("open-timeout"), arg),
                                    a(str("close-timeout"), arg),
                                    a(str("inactivity-timeout"), arg),
                                    a(str("inactivity-tcp-timeout"), arg),
                                    a(str("inactivity-asymm-tcp-timeout"), arg),
                                    a(str("inactivity-non-tcp-timeout"), arg),
                                    a(str("session-timeout"), arg),
                                    str("disable-global-timeout-override"),
                                    a(str("tcp-tickles"), arg),
                                    b(str("trio-flow-offload"),
                                        c(
                                            a(str("minimum-bytes"), arg)
                                        )
                                    ),
                                    a(str("fragment-limit"), arg),
                                    a(str("reassembly-timeout"), arg),
                                    str("cgn-pic"),
                                    a(str("pba-interim-logging-interval"), arg),
                                    b(str("session-limit"),
                                        c(
                                            a(str("maximum"), arg),
                                            a(str("rate"), arg),
                                            a(str("cpu-load-threshold"), arg)
                                        )
                                    ),
                                    str("enable-subscriber-analysis"),
                                    str("disable-usp-tracing"),
                                    str("disable-drop-flows"),
                                    b(str("ignore-errors"),
                                        sc(
                                            str("tcp"),
                                            str("alg")
                                        )
                                    ).as(:oneline),
                                    b(str("capture"),
                                        c(
                                            a(str("capture-size"), arg),
                                            a(str("pkt-size"), arg),
                                            a(str("logs-per-packet"), arg),
                                            a(str("max-log-line-size"), arg),
                                            b(str("filter"),
                                                c(
                                                    b(str("source-ip"),
                                                        sc(
                                                            b(str("wildcard"),
                                                              ipaddr
                                                            ),
                                                              ipaddr
                                                        )
                                                    ).as(:oneline),
                                                    b(str("dest-ip"),
                                                        sc(
                                                            b(str("wildcard"),
                                                              ipaddr
                                                            ),
                                                              ipaddr
                                                        )
                                                    ).as(:oneline),
                                                    b(str("sw-sip"),
                                                        sc(
                                                            b(str("wildcard"),
                                                              ipv6addr
                                                            ),
                                                              ipv6addr
                                                        )
                                                    ).as(:oneline),
                                                    b(str("sw-dip"),
                                                        sc(
                                                            b(str("wildcard"),
                                                              ipaddr
                                                            ),
                                                              ipaddr
                                                        )
                                                    ).as(:oneline),
                                                    b(str("sport-range"),
                                                        sc(
                                                            a(str("low"), arg),
                                                            a(str("high"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    b(str("dport-range"),
                                                        sc(
                                                            a(str("low"), arg),
                                                            a(str("high"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    b(str("proto"),
                                                      (str("icmp") | str("tcp") | str("udp"))
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("t3-options"),
                                c(
                                    b(str("loopback"),
                                      (str("local") | str("remote") | str("payload"))
                                    ),
                                    str("long-buildout"),
                                    str("no-long-buildout"),
                                    str("loop-timing"),
                                    str("no-loop-timing"),
                                    str("unframed"),
                                    str("no-unframed"),
                                    b(str("compatibility-mode"),
                                        sc(
                                            c(
                                              b(str("larscom"),
                                                  sc(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("verilink"),
                                                  sc(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("adtran"),
                                                  sc(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("kentrox"),
                                                  sc(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("digital-link"),
                                                  sc(
                                                      b(str("subrate"),
                                                        (str("301Kb") | str("601Kb") | str("902Kb") | str("1.2Mb") | str("1.5Mb") | str("1.8Mb") | str("2.1Mb") | str("2.4Mb") | str("2.7Mb") | str("3.0Mb") | str("3.3Mb") | str("3.6Mb") | str("3.9Mb") | str("4.2Mb") | str("4.5Mb") | str("4.8Mb") | str("5.1Mb") | str("5.4Mb") | str("5.7Mb") | str("6.0Mb") | str("6.3Mb") | str("6.6Mb") | str("6.9Mb") | str("7.2Mb") | str("7.5Mb") | str("7.8Mb") | str("8.1Mb") | str("8.4Mb") | str("8.7Mb") | str("9.0Mb") | str("9.3Mb") | str("9.6Mb") | str("9.9Mb") | str("10.2Mb") | str("10.5Mb") | str("10.8Mb") | str("11.1Mb") | str("11.4Mb") | str("11.7Mb") | str("12.0Mb") | str("12.3Mb") | str("12.6Mb") | str("12.9Mb") | str("13.2Mb") | str("13.5Mb") | str("13.8Mb") | str("14.1Mb") | str("14.4Mb") | str("14.7Mb") | str("15.0Mb") | str("15.3Mb") | str("15.6Mb") | str("15.9Mb") | str("16.2Mb") | str("16.5Mb") | str("16.8Mb") | str("17.1Mb") | str("17.4Mb") | str("17.7Mb") | str("18.0Mb") | str("18.3Mb") | str("18.6Mb") | str("18.9Mb") | str("19.2Mb") | str("19.5Mb") | str("19.8Mb") | str("20.1Mb") | str("20.5Mb") | str("20.8Mb") | str("21.1Mb") | str("21.4Mb") | str("21.7Mb") | str("22.0Mb") | str("22.3Mb") | str("22.6Mb") | str("22.9Mb") | str("23.2Mb") | str("23.5Mb") | str("23.8Mb") | str("24.1Mb") | str("24.4Mb") | str("24.7Mb") | str("25.0Mb") | str("25.3Mb") | str("25.6Mb") | str("25.9Mb") | str("26.2Mb") | str("26.5Mb") | str("26.8Mb") | str("27.1Mb") | str("27.4Mb") | str("27.7Mb") | str("28.0Mb") | str("28.3Mb") | str("28.6Mb") | str("28.9Mb") | str("29.2Mb") | str("29.5Mb") | str("29.8Mb") | str("30.1Mb") | str("30.4Mb") | str("30.7Mb") | str("31.0Mb") | str("31.3Mb") | str("31.6Mb") | str("31.9Mb") | str("32.2Mb") | str("32.5Mb") | str("32.8Mb") | str("33.1Mb") | str("33.4Mb") | str("33.7Mb") | str("34.0Mb") | str("34.3Mb") | str("34.6Mb") | str("34.9Mb") | str("35.2Mb") | str("35.5Mb") | str("35.8Mb") | str("36.1Mb") | str("36.4Mb") | str("36.7Mb") | str("37.0Mb") | str("37.3Mb") | str("37.6Mb") | str("37.9Mb") | str("38.2Mb") | str("38.5Mb") | str("38.8Mb") | str("39.1Mb") | str("39.4Mb") | str("39.7Mb") | str("40.0Mb") | str("40.3Mb") | str("40.6Mb") | str("40.9Mb") | str("41.2Mb") | str("41.5Mb") | str("41.8Mb") | str("42.1Mb") | str("42.4Mb") | str("42.7Mb") | str("43.0Mb") | str("43.3Mb") | str("43.6Mb") | str("43.9Mb") | str("44.2Mb"))
                                                      )
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    ).as(:oneline),
                                    str("payload-scrambler"),
                                    str("no-payload-scrambler"),
                                    str("cbit-parity"),
                                    str("no-cbit-parity"),
                                    b(str("fcs"),
                                      (str("32") | str("16"))
                                    ),
                                    b(str("idle-cycle-flag"),
                                      (str("flags") | str("ones"))
                                    ),
                                    b(str("start-end-flag"),
                                      (str("shared") | str("filler"))
                                    ),
                                    str("feac-loop-respond"),
                                    str("no-feac-loop-respond"),
                                    b(str("bert-algorithm"),
                                      (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                    ),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg),
                                    a(str("buildout"), arg),
                                    b(str("atm-encapsulation"),
                                      (str("plcp") | str("direct"))
                                    )
                                )
                            ),
                            b(str("e3-options"),
                                c(
                                    b(str("loopback"),
                                      (str("local") | str("remote"))
                                    ),
                                    str("unframed"),
                                    str("no-unframed"),
                                    b(str("compatibility-mode"),
                                        sc(
                                            c(
                                              str("larscom"),
                                              b(str("digital-link"),
                                                  sc(
                                                      b(str("subrate"),
                                                        (str("358Kb") | str("716Kb") | str("1.1Mb") | str("1.4Mb") | str("1.8Mb") | str("2.1Mb") | str("2.5Mb") | str("2.9Mb") | str("3.2Mb") | str("3.6Mb") | str("3.9Mb") | str("4.3Mb") | str("4.7Mb") | str("5.0Mb") | str("5.4Mb") | str("5.7Mb") | str("6.1Mb") | str("6.4Mb") | str("6.8Mb") | str("7.2Mb") | str("7.5Mb") | str("7.9Mb") | str("8.2Mb") | str("8.6Mb") | str("9.0Mb") | str("9.3Mb") | str("9.7Mb") | str("10.0Mb") | str("10.4Mb") | str("10.7Mb") | str("11.1Mb") | str("11.5Mb") | str("11.8Mb") | str("12.2Mb") | str("12.5Mb") | str("12.9Mb") | str("13.2Mb") | str("13.6Mb") | str("14.0Mb") | str("14.3Mb") | str("14.7Mb") | str("15.0Mb") | str("15.4Mb") | str("15.8Mb") | str("16.1Mb") | str("16.5Mb") | str("16.8Mb") | str("17.2Mb") | str("17.5Mb") | str("17.9Mb") | str("18.3Mb") | str("18.6Mb") | str("19.0Mb") | str("19.3Mb") | str("19.7Mb") | str("20.0Mb") | str("20.4Mb") | str("20.8Mb") | str("21.1Mb") | str("21.5Mb") | str("21.8Mb") | str("22.2Mb") | str("22.6Mb") | str("22.9Mb") | str("23.3Mb") | str("23.6Mb") | str("24.0Mb") | str("24.3Mb") | str("24.7Mb") | str("25.1Mb") | str("25.4Mb") | str("25.8Mb") | str("26.1Mb") | str("26.5Mb") | str("26.9Mb") | str("27.2Mb") | str("27.6Mb") | str("27.9Mb") | str("28.3Mb") | str("28.6Mb") | str("29.0Mb") | str("29.4Mb") | str("29.7Mb") | str("30.1Mb") | str("30.4Mb") | str("30.8Mb") | str("31.1Mb") | str("31.5Mb") | str("31.9Mb") | str("32.2Mb") | str("32.6Mb") | str("32.9Mb") | str("33.3Mb") | str("33.7Mb") | str("34.0Mb"))
                                                      )
                                                  )
                                              ).as(:oneline),
                                              b(str("kentrox"),
                                                  sc(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    ).as(:oneline),
                                    str("payload-scrambler"),
                                    str("no-payload-scrambler"),
                                    b(str("fcs"),
                                      (str("32") | str("16"))
                                    ),
                                    b(str("idle-cycle-flag"),
                                      (str("flags") | str("ones"))
                                    ),
                                    str("invert-data"),
                                    b(str("start-end-flag"),
                                      (str("shared") | str("filler"))
                                    ),
                                    b(str("bert-algorithm"),
                                      (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                    ),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg),
                                    a(str("buildout"), arg),
                                    b(str("atm-encapsulation"),
                                      (str("plcp") | str("direct"))
                                    ),
                                    b(str("framing"),
                                      (str("g.751") | str("g.832"))
                                    )
                                )
                            ),
                            b(str("e1-options"),
                                c(
                                    a(str("timeslots"), arg),
                                    b(str("loopback"),
                                      (str("local") | str("remote"))
                                    ),
                                    b(str("framing"),
                                      (str("g704") | str("unframed") | str("g704-no-crc4"))
                                    ),
                                    b(str("fcs"),
                                      (str("32") | str("16"))
                                    ),
                                    str("invert-data"),
                                    b(str("idle-cycle-flag"),
                                      (str("flags") | str("ones"))
                                    ),
                                    b(str("start-end-flag"),
                                      (str("shared") | str("filler"))
                                    ),
                                    b(str("bert-algorithm"),
                                      (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                    ),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg)
                                )
                            ),
                            b(str("t1-options"),
                                c(
                                    a(str("timeslots"), arg),
                                    a(str("voice-timeslots"), arg),
                                    b(str("disable-remote-alarm-detection"),
                                      (str("yellow"))
                                    ),
                                    b(str("loopback"),
                                      (str("local") | str("remote") | str("payload"))
                                    ),
                                    b(str("buildout"),
                                      (str("0-132") | str("133-265") | str("266-398") | str("399-531") | str("532-655") | str("long-0db") | str("long-7.5db") | str("long-15db") | str("long-22.5db"))
                                    ),
                                    b(str("byte-encoding"),
                                      (str("nx64") | str("nx56"))
                                    ),
                                    b(str("line-encoding"),
                                      (str("ami") | str("b8zs"))
                                    ),
                                    str("invert-data"),
                                    b(str("framing"),
                                      (str("sf") | str("esf"))
                                    ),
                                    b(str("fcs"),
                                      (str("32") | str("16"))
                                    ),
                                    b(str("idle-cycle-flag"),
                                      (str("flags") | str("ones"))
                                    ),
                                    b(str("start-end-flag"),
                                      (str("shared") | str("filler"))
                                    ),
                                    b(str("bert-algorithm"),
                                      (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                    ),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg),
                                    str("remote-loopback-respond"),
                                    b(str("crc-major-alarm-threshold"),
                                      (str("1e-3") | str("5e-4") | str("1e-4") | str("5e-5") | str("1e-5"))
                                    ),
                                    b(str("crc-minor-alarm-threshold"),
                                      (str("1e-3") | str("5e-4") | str("1e-4") | str("5e-5") | str("1e-5") | str("5e-6") | str("1e-6"))
                                    ),
                                    b(str("alarm-compliance"),
                                      (str("accunet-t1-5-service"))
                                    )
                                )
                            ),
                            b(str("ds0-options"),
                                c(
                                    b(str("loopback"),
                                      (str("payload"))
                                    ),
                                    b(str("byte-encoding"),
                                      (str("nx64") | str("nx56"))
                                    ),
                                    str("invert-data"),
                                    b(str("fcs"),
                                      (str("32") | str("16"))
                                    ),
                                    b(str("idle-cycle-flag"),
                                      (str("flags") | str("ones"))
                                    ),
                                    b(str("start-end-flag"),
                                      (str("shared") | str("filler"))
                                    ),
                                    b(str("bert-algorithm"),
                                      (str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4") | str("repeating-1-in-16"))
                                    ),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg)
                                )
                            ),
                            b(str("serial-options"),
                                c(
                                    b(str("line-protocol"),
                                      (str("eia530") | str("v.35") | str("x.21"))
                                    ),
                                    c(
                                      b(str("dte-options"),
                                          c(
                                              str("ignore-all"),
                                              b(str("dtr"),
                                                  sc(
                                                      c(
                                                        str("assert"),
                                                        str("de-assert"),
                                                        str("normal"),
                                                        b(str("auto-synchronize"),
                                                            c(
                                                                a(str("duration"), arg),
                                                                a(str("interval"), arg)
                                                            )
                                                        )
                                                      )
                                                  )
                                              ).as(:oneline),
                                              b(str("control-signal"),
                                                (str("assert") | str("de-assert") | str("normal"))
                                              ),
                                              b(str("rts"),
                                                (str("assert") | str("de-assert") | str("normal"))
                                              ),
                                              b(str("dcd"),
                                                (str("require") | str("ignore") | str("normal"))
                                              ),
                                              b(str("dsr"),
                                                (str("require") | str("ignore") | str("normal"))
                                              ),
                                              b(str("cts"),
                                                (str("require") | str("ignore") | str("normal"))
                                              ),
                                              b(str("indication"),
                                                (str("require") | str("ignore") | str("normal"))
                                              ),
                                              b(str("tm"),
                                                (str("require") | str("ignore") | str("normal"))
                                              )
                                          )
                                      ),
                                      b(str("dce-options"),
                                          c(
                                              str("ignore-all"),
                                              b(str("dtr"),
                                                (str("require") | str("ignore") | str("normal"))
                                              ),
                                              b(str("rts"),
                                                (str("require") | str("ignore") | str("normal"))
                                              ),
                                              b(str("dcd"),
                                                (str("assert") | str("de-assert") | str("normal"))
                                              ),
                                              b(str("dsr"),
                                                (str("assert") | str("de-assert") | str("normal"))
                                              ),
                                              b(str("cts"),
                                                (str("assert") | str("de-assert") | str("normal"))
                                              ),
                                              b(str("tm"),
                                                (str("require") | str("ignore") | str("normal"))
                                              ),
                                              str("dce-loopback-override")
                                          )
                                      )
                                    ),
                                    b(str("dtr-circuit"),
                                      (str("balanced") | str("unbalanced"))
                                    ),
                                    b(str("dtr-polarity"),
                                      (str("positive") | str("negative"))
                                    ),
                                    b(str("rts-polarity"),
                                      (str("positive") | str("negative"))
                                    ),
                                    b(str("control-polarity"),
                                      (str("positive") | str("negative"))
                                    ),
                                    b(str("dcd-polarity"),
                                      (str("positive") | str("negative"))
                                    ),
                                    b(str("dsr-polarity"),
                                      (str("positive") | str("negative"))
                                    ),
                                    b(str("cts-polarity"),
                                      (str("positive") | str("negative"))
                                    ),
                                    b(str("indication-polarity"),
                                      (str("positive") | str("negative"))
                                    ),
                                    b(str("tm-polarity"),
                                      (str("positive") | str("negative"))
                                    ),
                                    b(str("clocking-mode"),
                                      (str("dce") | str("internal") | str("loop"))
                                    ),
                                    b(str("transmit-clock"),
                                      (str("invert"))
                                    ),
                                    b(str("clock-rate"),
                                      (str("2.048mhz") | str("2.341mhz") | str("2.731mhz") | str("3.277mhz") | str("4.096mhz") | str("5.461mhz") | str("8.192mhz") | str("16.384mhz") | str("1.2khz") | str("2.4khz") | str("9.6khz") | str("19.2khz") | str("38.4khz") | str("56.0khz") | str("64.0khz") | str("72.0khz") | str("125.0khz") | str("148.0khz") | str("250.0khz") | str("500.0khz") | str("800.0khz") | str("1.0mhz") | str("1.3mhz") | str("2.0mhz") | str("4.0mhz") | str("8.0mhz"))
                                    ),
                                    b(str("loopback"),
                                      (str("local") | str("remote") | str("dce-local") | str("dce-remote"))
                                    ),
                                    b(str("encoding"),
                                      (str("nrz") | str("nrzi"))
                                    ),
                                    b(str("idle-cycle-flag"),
                                      (str("flags") | str("ones"))
                                    )
                                )
                            ),
                            str("gratuitous-arp-reply"),
                            str("no-gratuitous-arp-reply"),
                            str("no-gratuitous-arp-request"),
                            str("no-no-gratuitous-arp-request"),
                            str("arp-l2-validate"),
                            b(str("ether-options"),
                                c(
                                    str("loopback"),
                                    str("no-loopback"),
                                    str("source-filtering"),
                                    str("no-source-filtering"),
                                    b(str("ethernet-switch-profile"),
                                        c(
                                            a(str("tag-protocol-id"), arg),
                                            b(str("ethernet-policer-profile"),
                                                c(
                                                    b(str("input-priority-map"),
                                                      cos_policer_input_priority_map
                                                    ),
                                                    b(str("output-priority-map"),
                                                      cos_policer_output_priority_map
                                                    ),
                                                    b(str("policer"),
                                                      cos_policer
                                                    )
                                                )
                                            ),
                                            b(str("storm-control"),
                                                c(
                                                    arg
                                                )
                                            ),
                                            b(str("recovery-timeout"),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline),
                                            str("mac-learn-enable"),
                                            str("no-mac-learn-enable")
                                        )
                                    ),
                                    str("asynchronous-notification"),
                                    a(str("source-address-filter"), arg).as(:oneline),
                                    str("auto-negotiation"),
                                    str("no-auto-negotiation"),
                                    str("flow-control"),
                                    str("no-flow-control"),
                                    b(str("configured-flow-control"),
                                        c(
                                            b(str("rx-buffers"),
                                              (str("on") | str("off"))
                                            ),
                                            b(str("tx-buffers"),
                                              (str("on") | str("off"))
                                            )
                                        )
                                    ),
                                    b(str("link-mode"),
                                      (str("automatic") | str("half-duplex") | str("full-duplex"))
                                    ),
                                    b(str("mpls"),
                                      mpls_ifd_options
                                    ),
                                    str("ignore-l3-incompletes"),
                                    str("no-auto-mdix"),
                                    b(str("speed"),
                                        c(
                                            c(
                                              b(str("auto-negotiation"),
                                                  sc(
                                                      str("auto-negotiate-10-100")
                                                  )
                                              ).as(:oneline),
                                              str("ethernet-10m"),
                                              str("ethernet-100m"),
                                              str("ethernet-1g"),
                                              str("ethernet-10g")
                                            )
                                        )
                                    ),
                                    b(str("802.3ad"),
                                        c(
                                            b(str("lacp"),
                                                c(
                                                    str("force-up"),
                                                    a(str("port-priority"), arg)
                                                )
                                            ),
                                              interface_device,
                                            c(
                                              str("primary"),
                                              str("backup")
                                            ),
                                            b(str("link-protection-sub-group"),
                                                c(
                                                      arg
                                                )
                                            ),
                                            a(str("port-priority"), arg)
                                        )
                                    ),
                                    str("ieee-802-3az-eee"),
                                    b(str("mdi-mode"),
                                      (str("auto") | str("force") | str("mdi") | str("mdix"))
                                    ),
                                    b(str("redundant-parent"),
                                        c(
                                              interface_device
                                        )
                                    ),
                                    str("autostate-exclude")
                                )
                            ),
                            b(str("fibrechannel-options"),
                                c(
                                    str("loopback"),
                                    str("no-loopback"),
                                    a(str("bb-sc-n"), arg),
                                    b(str("speed"),
                                      (str("auto-negotiation") | str("1g") | str("2g") | str("4g") | str("8g"))
                                    )
                                )
                            ),
                            b(str("gigether-options"),
                                c(
                                    str("loopback"),
                                    str("no-loopback"),
                                    str("loopback-remote"),
                                    str("flow-control"),
                                    str("no-flow-control"),
                                    str("source-filtering"),
                                    str("no-source-filtering"),
                                    c(
                                      str("no-auto-negotiation"),
                                      b(str("auto-negotiation"),
                                          sc(
                                              b(str("remote-fault"),
                                                (str("local-interface-offline") | str("local-interface-online"))
                                              )
                                          )
                                      ).as(:oneline)
                                    ),
                                    b(str("mac-mode"),
                                      (str("sgmii") | str("mac-mode-1000base-x"))
                                    ),
                                    str("asynchronous-notification"),
                                    a(str("source-address-filter"), arg).as(:oneline),
                                    str("pad-to-minimum-frame-size"),
                                    b(str("redundant-parent"),
                                        c(
                                              interface_device
                                        )
                                    ),
                                    b(str("802.3ad"),
                                        c(
                                            b(str("lacp"),
                                                c(
                                                    a(str("port-priority"), arg)
                                                )
                                            ),
                                              interface_device,
                                            a(str("link-index"), arg),
                                            c(
                                              str("primary"),
                                              str("backup")
                                            ),
                                            a(str("distribution-list"), arg)
                                        )
                                    ),
                                    b(str("ethernet-switch-profile"),
                                        c(
                                            a(str("tag-protocol-id"), arg),
                                            b(str("ethernet-policer-profile"),
                                                c(
                                                    b(str("ieee802.1-priority-map"),
                                                        c(
                                                            a(str("premium"), arg)
                                                        )
                                                    ),
                                                    b(str("input-priority-map"),
                                                      cos_policer_input_priority_map
                                                    ),
                                                    b(str("output-priority-map"),
                                                      cos_policer_output_priority_map
                                                    ),
                                                    b(str("policer"),
                                                      cos_policer
                                                    )
                                                )
                                            ),
                                            b(str("accept-from"),
                                                c(
                                                    b(str("mac-address"),
                                                      mac_list
                                                    )
                                                )
                                            ),
                                            str("reject-the-rest"),
                                            str("no-reject-the-rest"),
                                            str("mac-learn-enable")
                                        )
                                    ),
                                    b(str("mpls"),
                                      mpls_ifd_options
                                    ),
                                    str("ignore-l3-incompletes"),
                                    str("no-auto-mdix"),
                                    str("ieee-802-3az-eee"),
                                    a(str("mru"), arg),
                                    b(str("fec"),
                                      (str("none") | str("fec91") | str("fec74") | str("fec108"))
                                    ),
                                    b(str("speed"),
                                      (str("1g") | str("10g"))
                                    )
                                )
                            ),
                            b(str("optics-options"),
                                c(
                                    b(str("wavelength"),
                                      (str("1568.77") | str("1568.36") | str("1568.31") | str("1568.26") | str("1568.21") | str("1568.16") | str("1568.11") | str("1568.05") | str("1568.00") | str("1567.95") | str("1567.90") | str("1567.85") | str("1567.80") | str("1567.75") | str("1567.70") | str("1567.64") | str("1567.59") | str("1567.54") | str("1567.49") | str("1567.44") | str("1567.39") | str("1567.34") | str("1567.29") | str("1567.23") | str("1567.18") | str("1567.13") | str("1567.08") | str("1567.03") | str("1566.98") | str("1566.93") | str("1566.88") | str("1566.83") | str("1566.77") | str("1566.72") | str("1566.67") | str("1566.62") | str("1566.57") | str("1566.52") | str("1566.47") | str("1566.42") | str("1566.36") | str("1566.31") | str("1566.26") | str("1566.21") | str("1566.16") | str("1566.11") | str("1566.06") | str("1566.01") | str("1565.96") | str("1565.90") | str("1565.85") | str("1565.80") | str("1565.75") | str("1565.70") | str("1565.65") | str("1565.60") | str("1565.55") | str("1565.50") | str("1565.44") | str("1565.39") | str("1565.34") | str("1565.29") | str("1565.24") | str("1565.19") | str("1565.14") | str("1565.09") | str("1565.04") | str("1564.99") | str("1564.93") | str("1564.88") | str("1564.83") | str("1564.78") | str("1564.73") | str("1564.68") | str("1564.63") | str("1564.58") | str("1564.53") | str("1564.47") | str("1564.42") | str("1564.37") | str("1564.32") | str("1564.27") | str("1564.22") | str("1564.17") | str("1564.12") | str("1564.07") | str("1564.02") | str("1563.96") | str("1563.91") | str("1563.86") | str("1563.81") | str("1563.76") | str("1563.71") | str("1563.66") | str("1563.61") | str("1563.56") | str("1563.51") | str("1563.45") | str("1563.40") | str("1563.35") | str("1563.30") | str("1563.25") | str("1563.20") | str("1563.15") | str("1563.10") | str("1563.05") | str("1563.00") | str("1562.95") | str("1562.89") | str("1562.84") | str("1562.79") | str("1562.74") | str("1562.69") | str("1562.64") | str("1562.59") | str("1562.54") | str("1562.49") | str("1562.44") | str("1562.39") | str("1562.33") | str("1562.28") | str("1562.23") | str("1562.18") | str("1562.13") | str("1562.08") | str("1562.03") | str("1561.98") | str("1561.93") | str("1561.88") | str("1561.83") | str("1561.77") | str("1561.72") | str("1561.67") | str("1561.62") | str("1561.57") | str("1561.52") | str("1561.47") | str("1561.42") | str("1561.37") | str("1561.32") | str("1561.27") | str("1561.22") | str("1561.16") | str("1561.11") | str("1561.06") | str("1561.01") | str("1560.96") | str("1560.91") | str("1560.86") | str("1560.81") | str("1560.76") | str("1560.71") | str("1560.66") | str("1560.61") | str("1560.56") | str("1560.50") | str("1560.45") | str("1560.40") | str("1560.35") | str("1560.30") | str("1560.25") | str("1560.20") | str("1560.15") | str("1560.10") | str("1560.05") | str("1560.00") | str("1559.95") | str("1559.90") | str("1559.84") | str("1559.79") | str("1559.74") | str("1559.69") | str("1559.64") | str("1559.59") | str("1559.54") | str("1559.49") | str("1559.44") | str("1559.39") | str("1559.34") | str("1559.29") | str("1559.24") | str("1559.19") | str("1559.14") | str("1559.08") | str("1559.03") | str("1558.98") | str("1558.93") | str("1558.88") | str("1558.83") | str("1558.78") | str("1558.73") | str("1558.68") | str("1558.63") | str("1558.58") | str("1558.53") | str("1558.48") | str("1558.43") | str("1558.38") | str("1558.32") | str("1558.27") | str("1558.22") | str("1558.17") | str("1558.12") | str("1558.07") | str("1558.02") | str("1557.97") | str("1557.92") | str("1557.87") | str("1557.82") | str("1557.77") | str("1557.72") | str("1557.67") | str("1557.62") | str("1557.57") | str("1557.52") | str("1557.46") | str("1557.41") | str("1557.36") | str("1557.31") | str("1557.26") | str("1557.21") | str("1557.16") | str("1557.11") | str("1557.06") | str("1557.01") | str("1556.96") | str("1556.91") | str("1556.86") | str("1556.81") | str("1556.76") | str("1556.71") | str("1556.66") | str("1556.61") | str("1556.55") | str("1556.50") | str("1556.45") | str("1556.40") | str("1556.35") | str("1556.30") | str("1556.25") | str("1556.20") | str("1556.15") | str("1556.10") | str("1556.05") | str("1556.00") | str("1555.95") | str("1555.90") | str("1555.85") | str("1555.80") | str("1555.75") | str("1555.70") | str("1555.65") | str("1555.60") | str("1555.55") | str("1555.49") | str("1555.44") | str("1555.39") | str("1555.34") | str("1555.29") | str("1555.24") | str("1555.19") | str("1555.14") | str("1555.09") | str("1555.04") | str("1554.99") | str("1554.94") | str("1554.89") | str("1554.84") | str("1554.79") | str("1554.74") | str("1554.69") | str("1554.64") | str("1554.59") | str("1554.54") | str("1554.49") | str("1554.44") | str("1554.39") | str("1554.34") | str("1554.29") | str("1554.23") | str("1554.18") | str("1554.13") | str("1554.08") | str("1554.03") | str("1553.98") | str("1553.93") | str("1553.88") | str("1553.83") | str("1553.78") | str("1553.73") | str("1553.68") | str("1553.63") | str("1553.58") | str("1553.53") | str("1553.48") | str("1553.43") | str("1553.38") | str("1553.33") | str("1553.28") | str("1553.23") | str("1553.18") | str("1553.13") | str("1553.08") | str("1553.03") | str("1552.98") | str("1552.93") | str("1552.88") | str("1552.83") | str("1552.78") | str("1552.73") | str("1552.68") | str("1552.62") | str("1552.57") | str("1552.52") | str("1552.47") | str("1552.42") | str("1552.37") | str("1552.32") | str("1552.27") | str("1552.22") | str("1552.17") | str("1552.12") | str("1552.07") | str("1552.02") | str("1551.97") | str("1551.92") | str("1551.87") | str("1551.82") | str("1551.77") | str("1551.72") | str("1551.67") | str("1551.62") | str("1551.57") | str("1551.52") | str("1551.47") | str("1551.42") | str("1551.37") | str("1551.32") | str("1551.27") | str("1551.22") | str("1551.17") | str("1551.12") | str("1551.07") | str("1551.02") | str("1550.97") | str("1550.92") | str("1550.87") | str("1550.82") | str("1550.77") | str("1550.72") | str("1550.67") | str("1550.62") | str("1550.57") | str("1550.52") | str("1550.47") | str("1550.42") | str("1550.37") | str("1550.32") | str("1550.27") | str("1550.22") | str("1550.17") | str("1550.12") | str("1550.07") | str("1550.02") | str("1549.97") | str("1549.92") | str("1549.87") | str("1549.82") | str("1549.77") | str("1549.72") | str("1549.67") | str("1549.62") | str("1549.57") | str("1549.52") | str("1549.47") | str("1549.42") | str("1549.37") | str("1549.32") | str("1549.26") | str("1549.21") | str("1549.16") | str("1549.11") | str("1549.06") | str("1549.01") | str("1548.96") | str("1548.91") | str("1548.86") | str("1548.81") | str("1548.76") | str("1548.71") | str("1548.66") | str("1548.61") | str("1548.56") | str("1548.51") | str("1548.46") | str("1548.41") | str("1548.36") | str("1548.31") | str("1548.26") | str("1548.21") | str("1548.16") | str("1548.11") | str("1548.06") | str("1548.02") | str("1547.97") | str("1547.92") | str("1547.87") | str("1547.82") | str("1547.77") | str("1547.72") | str("1547.67") | str("1547.62") | str("1547.57") | str("1547.52") | str("1547.47") | str("1547.42") | str("1547.37") | str("1547.32") | str("1547.27") | str("1547.22") | str("1547.17") | str("1547.12") | str("1547.07") | str("1547.02") | str("1546.97") | str("1546.92") | str("1546.87") | str("1546.82") | str("1546.77") | str("1546.72") | str("1546.67") | str("1546.62") | str("1546.57") | str("1546.52") | str("1546.47") | str("1546.42") | str("1546.37") | str("1546.32") | str("1546.27") | str("1546.22") | str("1546.17") | str("1546.12") | str("1546.07") | str("1546.02") | str("1545.97") | str("1545.92") | str("1545.87") | str("1545.82") | str("1545.77") | str("1545.72") | str("1545.67") | str("1545.62") | str("1545.57") | str("1545.52") | str("1545.47") | str("1545.42") | str("1545.37") | str("1545.32") | str("1545.27") | str("1545.22") | str("1545.17") | str("1545.12") | str("1545.07") | str("1545.02") | str("1544.97") | str("1544.92") | str("1544.87") | str("1544.82") | str("1544.77") | str("1544.72") | str("1544.68") | str("1544.63") | str("1544.58") | str("1544.53") | str("1544.48") | str("1544.43") | str("1544.38") | str("1544.33") | str("1544.28") | str("1544.23") | str("1544.18") | str("1544.13") | str("1544.08") | str("1544.03") | str("1543.98") | str("1543.93") | str("1543.88") | str("1543.83") | str("1543.78") | str("1543.73") | str("1543.68") | str("1543.63") | str("1543.58") | str("1543.53") | str("1543.48") | str("1543.43") | str("1543.38") | str("1543.33") | str("1543.28") | str("1543.23") | str("1543.18") | str("1543.13") | str("1543.08") | str("1543.04") | str("1542.99") | str("1542.94") | str("1542.89") | str("1542.84") | str("1542.79") | str("1542.74") | str("1542.69") | str("1542.64") | str("1542.59") | str("1542.54") | str("1542.49") | str("1542.44") | str("1542.39") | str("1542.34") | str("1542.29") | str("1542.24") | str("1542.19") | str("1542.14") | str("1542.09") | str("1542.04") | str("1541.99") | str("1541.94") | str("1541.89") | str("1541.84") | str("1541.80") | str("1541.75") | str("1541.70") | str("1541.65") | str("1541.60") | str("1541.55") | str("1541.50") | str("1541.45") | str("1541.40") | str("1541.35") | str("1541.30") | str("1541.25") | str("1541.20") | str("1541.15") | str("1541.10") | str("1541.05") | str("1541.00") | str("1540.95") | str("1540.90") | str("1540.85") | str("1540.80") | str("1540.76") | str("1540.71") | str("1540.66") | str("1540.61") | str("1540.56") | str("1540.51") | str("1540.46") | str("1540.41") | str("1540.36") | str("1540.31") | str("1540.26") | str("1540.21") | str("1540.16") | str("1540.11") | str("1540.06") | str("1540.01") | str("1539.96") | str("1539.91") | str("1539.86") | str("1539.82") | str("1539.77") | str("1539.72") | str("1539.67") | str("1539.62") | str("1539.57") | str("1539.52") | str("1539.47") | str("1539.42") | str("1539.37") | str("1539.32") | str("1539.27") | str("1539.22") | str("1539.17") | str("1539.12") | str("1539.07") | str("1539.03") | str("1538.98") | str("1538.93") | str("1538.88") | str("1538.83") | str("1538.78") | str("1538.73") | str("1538.68") | str("1538.63") | str("1538.58") | str("1538.53") | str("1538.48") | str("1538.43") | str("1538.38") | str("1538.33") | str("1538.28") | str("1538.24") | str("1538.19") | str("1538.14") | str("1538.09") | str("1538.04") | str("1537.99") | str("1537.94") | str("1537.89") | str("1537.84") | str("1537.79") | str("1537.74") | str("1537.69") | str("1537.64") | str("1537.59") | str("1537.55") | str("1537.50") | str("1537.45") | str("1537.40") | str("1537.35") | str("1537.30") | str("1537.25") | str("1537.20") | str("1537.15") | str("1537.10") | str("1537.05") | str("1537.00") | str("1536.95") | str("1536.90") | str("1536.86") | str("1536.81") | str("1536.76") | str("1536.71") | str("1536.66") | str("1536.61") | str("1536.56") | str("1536.51") | str("1536.46") | str("1536.41") | str("1536.36") | str("1536.31") | str("1536.26") | str("1536.22") | str("1536.17") | str("1536.12") | str("1536.07") | str("1536.02") | str("1535.97") | str("1535.92") | str("1535.87") | str("1535.82") | str("1535.77") | str("1535.72") | str("1535.67") | str("1535.63") | str("1535.58") | str("1535.53") | str("1535.48") | str("1535.43") | str("1535.38") | str("1535.33") | str("1535.28") | str("1535.23") | str("1535.18") | str("1535.13") | str("1535.08") | str("1535.04") | str("1534.99") | str("1534.94") | str("1534.89") | str("1534.84") | str("1534.79") | str("1534.74") | str("1534.69") | str("1534.64") | str("1534.59") | str("1534.54") | str("1534.50") | str("1534.45") | str("1534.40") | str("1534.35") | str("1534.30") | str("1534.25") | str("1534.20") | str("1534.15") | str("1534.10") | str("1534.05") | str("1534.00") | str("1533.96") | str("1533.91") | str("1533.86") | str("1533.81") | str("1533.76") | str("1533.71") | str("1533.66") | str("1533.61") | str("1533.56") | str("1533.51") | str("1533.47") | str("1533.42") | str("1533.37") | str("1533.32") | str("1533.27") | str("1533.22") | str("1533.17") | str("1533.12") | str("1533.07") | str("1533.02") | str("1532.98") | str("1532.93") | str("1532.88") | str("1532.83") | str("1532.78") | str("1532.73") | str("1532.68") | str("1532.63") | str("1532.58") | str("1532.53") | str("1532.49") | str("1532.44") | str("1532.39") | str("1532.34") | str("1532.29") | str("1532.24") | str("1532.19") | str("1532.14") | str("1532.09") | str("1532.04") | str("1532.00") | str("1531.95") | str("1531.90") | str("1531.85") | str("1531.80") | str("1531.75") | str("1531.70") | str("1531.65") | str("1531.60") | str("1531.56") | str("1531.51") | str("1531.46") | str("1531.41") | str("1531.36") | str("1531.31") | str("1531.26") | str("1531.21") | str("1531.16") | str("1531.12") | str("1531.07") | str("1531.02") | str("1530.97") | str("1530.92") | str("1530.87") | str("1530.82") | str("1530.77") | str("1530.72") | str("1530.68") | str("1530.63") | str("1530.58") | str("1530.53") | str("1530.48") | str("1530.43") | str("1530.38") | str("1530.33") | str("1530.29") | str("1530.24") | str("1530.19") | str("1530.14") | str("1530.09") | str("1530.04") | str("1529.99") | str("1529.94") | str("1529.89") | str("1529.85") | str("1529.80") | str("1529.75") | str("1529.70") | str("1529.65") | str("1529.60") | str("1529.55") | str("1529.50") | str("1529.46") | str("1529.41") | str("1529.36") | str("1529.31") | str("1529.26") | str("1529.21") | str("1529.16") | str("1529.11") | str("1529.07") | str("1529.02") | str("1528.97") | str("1528.92") | str("1528.87") | str("1528.82") | str("1528.77") | str("1528.38"))
                                    ),
                                    a(str("tx-power"), arg),
                                    str("loopback"),
                                    a(str("los-warning-threshold"), arg),
                                    a(str("los-alarm-threshold"), arg),
                                    b(str("modulation-format"),
                                      (str("16qam") | str("8qam") | str("qpsk"))
                                    ),
                                    str("laser-enable"),
                                    str("no-laser-enable"),
                                    str("is-ma"),
                                    str("no-is-ma"),
                                    b(str("encoding"),
                                      (str("differential") | str("non-differential"))
                                    ),
                                    b(str("fec"),
                                      (str("sdfec") | str("sdfec25") | str("hgfec") | str("sdfec15"))
                                    ),
                                    str("high-polarization"),
                                    b(str("signal-degrade"),
                                        c(
                                            a(str("interval"), arg),
                                            a(str("ber-threshold-clear"), arg),
                                            a(str("ber-threshold-signal-degrade"), arg),
                                            a(str("q-threshold-signal-degrade-clear"), arg),
                                            a(str("q-threshold-signal-degrade"), arg)
                                        )
                                    ),
                                    a(str("alarm"), enum(str("low-light-alarm")),
                                        c(
                                            c(
                                              str("syslog"),
                                              str("link-down")
                                            )
                                        )
                                    ),
                                    b(str("tca"),
                                        c(
                                            b(str("tx-power-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("tx-power-low-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("rx-power-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("rx-power-low-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("temperature-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("temperature-low-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("carrier-frequency-offset-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("carrier-frequency-offset-low-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("fec-ber"),
                                                sc(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ).as(:oneline),
                                            b(str("tec-current-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("tec-current-low-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("residual-isi-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("residual-isi-low-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("pam-histogram-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("snr-low-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("fec-corrected-errors-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("fec-ucorrected-words-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("laser-frequency-error-high-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            ),
                                            b(str("laser-frequency-error-low-tca"),
                                                c(
                                                    str("enable-tca"),
                                                    str("no-enable-tca"),
                                                    a(str("threshold"), arg),
                                                    a(str("threshold-24hrs"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    a(str("warning"), enum(str("low-light-warning")),
                                        c(
                                            c(
                                              str("syslog"),
                                              str("link-down")
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("otn-options"),
                              otn_options_type
                            ),
                            b(str("och-options"),
                              och_attributes
                            ),
                            b(str("otu-options"),
                              otu_attributes
                            ),
                            b(str("odu-options"),
                              odu_attributes
                            ),
                            b(str("ett-options"),
                              ett_attributes
                            ),
                            b(str("fastether-options"),
                                c(
                                    str("loopback"),
                                    str("no-loopback"),
                                    str("flow-control"),
                                    str("no-flow-control"),
                                    str("source-filtering"),
                                    str("no-source-filtering"),
                                    str("auto-negotiation"),
                                    str("no-auto-negotiation"),
                                    a(str("ingress-rate-limit"), arg),
                                    a(str("source-address-filter"), arg).as(:oneline),
                                    b(str("redundant-parent"),
                                        c(
                                              interface_device
                                        )
                                    ),
                                    b(str("802.3ad"),
                                        c(
                                            b(str("lacp"),
                                                c(
                                                    a(str("port-priority"), arg)
                                                )
                                            ),
                                              interface_device,
                                            c(
                                              str("primary"),
                                              str("backup")
                                            )
                                        )
                                    ),
                                    b(str("mpls"),
                                      mpls_ifd_options
                                    ),
                                    str("ignore-l3-incompletes")
                                )
                            ),
                            b(str("redundant-ether-options"),
                                c(
                                    a(str("redundancy-group"), arg),
                                    str("loopback"),
                                    str("no-loopback"),
                                    str("flow-control"),
                                    str("no-flow-control"),
                                    str("source-filtering"),
                                    str("no-source-filtering"),
                                    a(str("source-address-filter"), arg).as(:oneline),
                                    b(str("link-speed"),
                                      (str("10m") | str("100m") | str("1g") | str("10g"))
                                    ),
                                    a(str("minimum-links"), arg),
                                    b(str("lacp"),
                                        c(
                                            c(
                                              str("active"),
                                              str("passive")
                                            ),
                                            b(str("periodic"),
                                              (str("fast") | str("slow"))
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("aggregated-ether-options"),
                                c(
                                    str("loopback"),
                                    str("no-loopback"),
                                    str("flow-control"),
                                    str("no-flow-control"),
                                    str("source-filtering"),
                                    str("no-source-filtering"),
                                    str("autostate-exclude"),
                                    b(str("link-protection"),
                                        c(
                                            str("revertive"),
                                            str("non-revertive"),
                                            b(str("backup-state"),
                                              (str("accept-data") | str("discard-data") | str("down"))
                                            ),
                                            b(str("rtg-config"),
                                                c(
                                                    a(str("preempt-cutover-timer"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    str("fcoe-lag"),
                                    str("no-fcoe-lag"),
                                    a(str("source-address-filter"), arg).as(:oneline),
                                    b(str("configured-flow-control"),
                                        c(
                                            b(str("rx-buffers"),
                                              (str("on") | str("off"))
                                            ),
                                            b(str("tx-buffers"),
                                              (str("on") | str("off"))
                                            )
                                        )
                                    ),
                                    b(str("load-balance"),
                                      aggregate_load_balance
                                    ),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("version"),
                                              (str("0") | str("1") | str("automatic"))
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("minimum-transmit-interval"), arg),
                                            a(str("minimum-receive-interval"), arg),
                                            a(str("multiplier"), arg),
                                            c(
                                              str("no-adaptation")
                                            ),
                                            b(str("transmit-interval"),
                                                c(
                                                    a(str("minimum-interval"), arg),
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("detection-time"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("authentication"),
                                                c(
                                                    a(str("key-chain"), arg),
                                                    b(str("algorithm"),
                                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                    ),
                                                    str("loose-check")
                                                )
                                            ),
                                            b(str("neighbor"),
                                              ipaddr
                                            ),
                                            b(str("local-address"),
                                              ipaddr
                                            ),
                                            a(str("holddown-interval"), arg)
                                        )
                                    ),
                                    a(str("minimum-links"), arg),
                                    b(str("minimum-bandwidth"),
                                        c(
                                            a(str("bw-value"), arg),
                                            b(str("bw-unit"),
                                              (str("bps") | str("kbps") | str("mbps") | str("gbps"))
                                            )
                                        )
                                    ),
                                    b(str("targeted-options"),
                                        c(
                                            b(str("type"),
                                              (str("auto") | str("manual"))
                                            ),
                                            c(
                                              str("logical-interface-fpc-redundancy"),
                                              str("logical-interface-chassis-redundancy")
                                            ),
                                            b(str("rebalance-periodic"),
                                                c(
                                                    b(str("start-time"),
                                                      date
                                                    ),
                                                    a(str("interval"), arg)
                                                )
                                            ),
                                            a(str("rebalance-subscriber-granularity"), arg)
                                        )
                                    ),
                                    c(
                                      str("logical-interface-fpc-redundancy"),
                                      str("logical-interface-chassis-redundancy")
                                    ),
                                    b(str("rebalance-periodic"),
                                        c(
                                            b(str("start-time"),
                                              date
                                            ),
                                            a(str("interval"), arg)
                                        )
                                    ),
                                    str("pad-to-minimum-frame-size"),
                                    b(str("link-speed"),
                                      (str("10m") | str("100m") | str("1g") | str("2.5g") | str("5g") | str("8g") | str("10g") | str("25g") | str("40g") | str("50g") | str("80g") | str("100g") | str("400g") | str("oc192") | str("mixed"))
                                    ),
                                    b(str("local-bias"),
                                        c(
                                            str("disable")
                                        )
                                    ),
                                    a(str("local-minimum-links-threshold"), arg),
                                    str("resilient-hash"),
                                    b(str("lacp"),
                                        c(
                                            c(
                                              str("active"),
                                              str("passive")
                                            ),
                                            b(str("periodic"),
                                              (str("fast") | str("slow"))
                                            ),
                                            str("fast-failover"),
                                            b(str("link-protection"),
                                                c(
                                                    str("disable"),
                                                    c(
                                                      str("revertive"),
                                                      str("non-revertive")
                                                    ),
                                                    b(str("rtg-config"),
                                                        c(
                                                            a(str("preempt-cutover-timer"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            str("accept-data"),
                                            b(str("sync-reset"),
                                              (str("disable") | str("enable"))
                                            ),
                                            a(str("system-priority"), arg),
                                            b(str("system-id"),
                                              mac_addr
                                            ),
                                            a(str("admin-key"), arg),
                                            b(str("hold-time"),
                                                sc(
                                                    a(str("up"), arg)
                                                )
                                            ).as(:oneline),
                                            a(str("aggregate-wait-time"), arg),
                                            str("force-up"),
                                            str("no-peer-loopback-validation")
                                        )
                                    ),
                                    b(a(str("link-protection-sub-group"), arg),
                                        c(
                                            c(
                                              str("primary"),
                                              str("backup")
                                            )
                                        )
                                    ),
                                    b(str("ethernet-switch-profile"),
                                        c(
                                            a(str("tag-protocol-id"), arg),
                                            b(str("storm-control"),
                                                c(
                                                    arg
                                                )
                                            ),
                                            str("mac-learn-enable")
                                        )
                                    ),
                                    b(str("mc-ae"),
                                        c(
                                            a(str("mc-ae-id"), arg),
                                            a(str("redundancy-group"), arg),
                                            a(str("chassis-id"), arg),
                                            b(str("mode"),
                                              (str("active-standby") | str("active-active"))
                                            ),
                                            b(str("status-control"),
                                              (str("active") | str("standby"))
                                            ),
                                            b(str("switchover-mode"),
                                              (str("revertive") | str("non-revertive"))
                                            ),
                                            a(str("revert-time"), arg),
                                            a(str("init-delay-time"), arg),
                                            a(str("recovery-delay-time"), arg),
                                            str("enhanced-convergence"),
                                            b(str("events"),
                                                c(
                                                    b(str("iccp-peer-down"),
                                                        c(
                                                            str("force-icl-down"),
                                                            str("prefer-status-control-active")
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    str("share-standby")
                                )
                            ),
                            b(str("es-options"),
                                c(
                                    b(str("backup-interface"),
                                      interface_device
                                    )
                                )
                            ),
                            b(str("dsl-options"),
                                c(
                                    b(str("operating-mode"),
                                      (str("auto") | str("ansi-dmt") | str("itu-dmt") | str("etsi") | str("itu-annexb-ur2") | str("itu-annexb-non-ur2") | str("itu-dmt-bis") | str("adsl2plus") | str("annexm-itu-dmt-bis") | str("annexm-adsl2plus"))
                                    )
                                )
                            ),
                            b(str("vdsl-options"),
                                c(
                                    b(str("vdsl-profile"),
                                      (str("auto") | str("8a") | str("8b") | str("8c") | str("8d") | str("12a") | str("12b") | str("17a"))
                                    ),
                                    b(str("sra"),
                                      (str("enable") | str("disable"))
                                    ),
                                    b(str("v43"),
                                      (str("enable") | str("disable"))
                                    ),
                                    str("sos")
                                )
                            ),
                            b(str("dsl-sfp-options"),
                                c(
                                    b(str("adsl-options"),
                                        c(
                                            a(str("vpi"), arg),
                                            a(str("vci"), arg),
                                            b(str("encap"),
                                              (str("bypass") | str("llcsnap-bridged-802dot1q") | str("llcsnap-routed-ip") | str("vc-mux-bridged") | str("vc-mux-routed-ip") | str("generic"))
                                            )
                                        )
                                    ),
                                    b(str("vdsl-options"),
                                        c(
                                            b(str("profile"),
                                              (str("auto") | str("8a") | str("8b") | str("8c") | str("8d") | str("12a") | str("12b") | str("17a") | str("30a"))
                                            ),
                                            b(str("carrier"),
                                              (str("auto") | str("a43") | str("b43"))
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("shdsl-options"),
                                c(
                                    b(str("annex"),
                                      (str("annex-a") | str("annex-b") | str("annex-f") | str("annex-g") | str("annex-auto"))
                                    ),
                                    b(str("line-rate"),
                                      (str("auto") | arg)
                                    ),
                                    b(str("loopback"),
                                      (str("local") | str("remote"))
                                    ),
                                    b(str("snr-margin"),
                                        c(
                                            b(str("current"),
                                              (str("disable") | arg)
                                            ),
                                            b(str("snext"),
                                              (str("disable") | arg)
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("data-input"),
                                c(
                                    c(
                                      str("system"),
                                      b(str("interface"),
                                        interface_device
                                      )
                                    )
                                )
                            ),
                            b(str("switch-options"),
                                c(
                                    b(a(str("switch-port"), arg),
                                        c(
                                            str("auto-negotiation"),
                                            str("no-auto-negotiation"),
                                            b(str("link-mode"),
                                              (str("half-duplex") | str("full-duplex"))
                                            ),
                                            b(str("speed"),
                                              (str("10m") | str("100m") | str("1g"))
                                            ),
                                            a(str("vlan-id"), arg),
                                            str("cascade-port")
                                        )
                                    )
                                )
                            ),
                            b(str("container-options"),
                                c(
                                    b(str("container-type"),
                                        c(
                                            c(
                                              b(str("aps"),
                                                aps_type
                                              )
                                            )
                                        )
                                    ),
                                    b(str("member-interface-type"),
                                        c(
                                            c(
                                              b(str("sonet"),
                                                  c(
                                                      b(str("member-interface-speed"),
                                                        (str("oc3") | str("oc12") | str("oc48") | str("oc192") | str("oc768") | str("mixed"))
                                                      )
                                                  )
                                              ),
                                              b(str("atm"),
                                                  c(
                                                      b(str("member-interface-speed"),
                                                        (str("oc3") | str("oc12") | str("oc48"))
                                                      )
                                                  )
                                              ),
                                              b(str("channelized-sonet"),
                                                  c(
                                                      b(str("member-interface-speed"),
                                                        (str("coc3") | str("coc12") | str("coc48") | str("coc192") | str("coc768"))
                                                      )
                                                  )
                                              ),
                                              b(str("channelized-sdh"),
                                                  c(
                                                      b(str("member-interface-speed"),
                                                        (str("cstm1") | str("cstm4") | str("cstm16") | str("coc64") | str("cstm256"))
                                                      )
                                                  )
                                              )
                                            )
                                        )
                                    ),
                                    b(str("redundancy"),
                                        c(
                                            b(str("hold-time"),
                                                sc(
                                                    a(str("up"), arg),
                                                    a(str("down"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("container-list"),
                                      interface_device
                                    ),
                                    c(
                                        str("primary"),
                                        str("standby")
                                    ),
                                    str("fast-aps"),
                                    str("allow-configuration-override")
                                )
                            ),
                            b(str("layer2-policer"),
                                c(
                                    c(
                                      a(str("input-policer"), arg),
                                      a(str("input-hierarchical-policer"), arg)
                                    )
                                )
                            ),
                            a(str("unit"), enum(arg | arg | arg),
                                c(
                                    b(str("policer-overhead"),
                                        ca(
                                            a(str("ingress"), arg),
                                            a(str("egress"), arg)
                                        )
                                    ),
                                    a(str("alias"), arg),
                                    str("enhanced-convergence"),
                                    str("proxy-macip-advertisement"),
                                    str("virtual-gateway-accept-data"),
                                    b(str("peer-psd"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("peer-interface"),
                                        c(
                                              interface_unit
                                        )
                                    ),
                                    b(str("interface-shared-with"),
                                        c(
                                            arg
                                        )
                                    ),
                                      (str("disable")),
                                    str("passive-monitor-mode"),
                                    str("per-session-scheduler"),
                                    b(str("account-layer2-overhead"),
                                        ca(
                                            a(str("ingress"), arg),
                                            a(str("egress"), arg)
                                        )
                                    ),
                                    b(str("forwarding-class-accounting"),
                                        c(
                                            b(str("direction"),
                                              (str("ingress") | str("egress") | str("both"))
                                            ),
                                            b(str("enhanced"),
                                                c(
                                                    b(str("traffic-type"),
                                                      (str("unicast-statistics") | str("multicast-statistics"))
                                                    ),
                                                    b(str("family"),
                                                      (str("inet6") | str("inet") | str("both"))
                                                    ),
                                                    b(str("direction"),
                                                      (str("ingress") | str("egress") | str("both"))
                                                    ),
                                                    a(str("overhead-bytes"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    str("clear-dont-fragment-bit"),
                                    str("packet-inject-enable"),
                                    str("reassemble-packets"),
                                    str("services-options"),
                                    b(str("rpm"),
                                        c(
                                            c(
                                              c(
                                                str("client"),
                                                str("server"),
                                                str("client-delegate-probes")
                                              ),
                                              str("twamp-server"),
                                              str("twamp-client")
                                            )
                                        )
                                    ),
                                    a(str("description"), quote | arg),
                                    a(str("metadata"), arg),
                                    b(str("dial-options"),
                                        c(
                                            c(
                                              a(str("l2tp-interface-id"), arg),
                                              a(str("ipsec-interface-id"), arg)
                                            ),
                                            c(
                                              str("dedicated"),
                                              str("shared")
                                            )
                                        )
                                    ),
                                    str("actual-transit-statistics"),
                                    b(str("demux-source"),
                                          enum((str("inet6") | str("inet")))
                                    ),
                                    b(str("demux-destination"),
                                          enum((str("inet6") | str("inet")))
                                    ),
                                    b(str("demux"),
                                        c(
                                            b(str("inet"),
                                                c(
                                                    b(str("address"),
                                                      (str("source") | str("destination"))
                                                    ),
                                                    b(str("auto-configure"),
                                                      dynamic_ipv4_type
                                                    )
                                                )
                                            ),
                                            b(str("inet6"),
                                                c(
                                                    b(str("address"),
                                                      (str("source") | str("destination"))
                                                    ),
                                                    b(str("auto-configure"),
                                                      dynamic_ipv6_type
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("encapsulation"),
                                      (str("atm-nlpid") | str("atm-cisco-nlpid") | str("atm-snap") | str("atm-vc-mux") | str("atm-ccc-vc-mux") | str("atm-tcc-vc-mux") | str("atm-tcc-snap") | str("atm-ccc-cell-relay") | str("vlan-vci-ccc") | str("ether-over-atm-llc") | str("ether-vpls-over-atm-llc") | str("ppp-over-ether-over-atm-llc") | str("ppp-over-ether") | str("atm-ppp-vc-mux") | str("atm-ppp-llc") | str("atm-mlppp-llc") | str("frame-relay-ppp") | str("frame-relay-ccc") | str("frame-relay") | str("frame-relay-tcc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("ether-vpls-fr") | str("vlan-ccc") | str("ethernet-ccc") | str("vlan-vpls") | str("vlan-bridge") | str("dix") | str("ethernet-vpls") | str("ethernet-bridge") | str("ethernet") | str("vlan") | str("vlan-tcc") | str("multilink-ppp") | str("multilink-frame-relay-end-to-end") | str("ppp-ccc"))
                                    ),
                                    str("gre"),
                                    a(str("mtu"), arg),
                                    c(
                                      str("point-to-point"),
                                      str("multipoint")
                                    ),
                                    a(str("bandwidth"), arg),
                                    a(str("global-layer2-domainid"), arg),
                                    b(str("radio-router"),
                                      dynamic_ifbw_parms_type
                                    ),
                                    str("traps"),
                                    str("no-traps"),
                                    str("routing-services"),
                                    str("no-routing-services"),
                                    b(str("routing-service"),
                                        c(
                                              (str("enable") | str("disable"))
                                        )
                                    ),
                                    b(str("arp-resp"),
                                        sc(
                                            c(
                                              str("unrestricted"),
                                              str("restricted")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("proxy-arp"),
                                        sc(
                                            c(
                                              str("unrestricted"),
                                              str("restricted")
                                            )
                                        )
                                    ).as(:oneline),
                                    c(
                                      b(str("vlan-id"),
                                        (str("none") | arg)
                                      ),
                                      a(str("vlan-id-range"), arg),
                                      a(str("inner-vlan-id-swap-ranges"), arg),
                                      a(str("vlan-id-list"), arg),
                                      a(str("vlan-tag"), arg),
                                      b(str("vlan-tags"),
                                          sc(
                                              b(str("outer"),
                                                (arg | arg | arg)
                                              ),
                                              c(
                                                b(str("inner"),
                                                  (arg | arg)
                                                ),
                                                a(str("inner-range"), arg),
                                                a(str("inner-list"), arg)
                                              )
                                          )
                                      ).as(:oneline)
                                    ),
                                    a(str("deep-vlan-qualified-learning"), arg),
                                    a(str("native-inner-vlan-id"), arg),
                                    b(str("inner-vlan-id-range"),
                                        sc(
                                            a(str("start"), arg),
                                            a(str("end"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("accept-source-mac"),
                                        c(
                                            b(str("mac-address"),
                                              mac_list
                                            )
                                        )
                                    ),
                                    b(str("input-vlan-map"),
                                      vlan_map
                                    ),
                                    b(str("output-vlan-map"),
                                      vlan_map
                                    ),
                                    str("swap-by-poppush"),
                                    a(str("receive-lsp"), arg),
                                    a(str("transmit-lsp"), arg),
                                    a(str("dlci"), arg),
                                    a(str("multicast-dlci"), arg),
                                    c(
                                      b(str("vci"),
                                        atm_vci
                                      ),
                                      str("allow-any-vci"),
                                      a(str("vpi"), arg),
                                      a(str("trunk-id"), arg)
                                    ),
                                    str("no-vpivci-swapping"),
                                    c(
                                      b(str("psn-vci"),
                                        atm_vci
                                      ),
                                      a(str("psn-vpi"), arg)
                                    ),
                                    b(str("atm-l2circuit-mode"),
                                        sc(
                                            c(
                                              str("cell"),
                                              str("aal5")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("vci-range"),
                                        sc(
                                            a(str("start"), arg),
                                            a(str("end"), arg)
                                        )
                                    ).as(:oneline),
                                    a(str("trunk-bandwidth"), arg),
                                    b(str("multicast-vci"),
                                      atm_vci
                                    ),
                                    b(str("shaping"),
                                      dcd_shaping_config
                                    ),
                                    b(str("oam-period"),
                                        sc(
                                            ca(
                                              str("disable").as(:oneline)
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("oam-liveness"),
                                        c(
                                            a(str("up-count"), arg),
                                            a(str("down-count"), arg)
                                        )
                                    ),
                                    b(str("ppp-options"),
                                      ppp_options_type
                                    ),
                                    b(str("pppoe-options"),
                                      pppoe_options_type
                                    ),
                                    b(str("pppoe-underlying-options"),
                                      pppoe_underlying_options_type
                                    ),
                                    b(str("advisory-options"),
                                      advisory_options_type
                                    ),
                                    b(str("auto-configure"),
                                      auto_configure_vlan_type
                                    ),
                                    b(str("demux-options"),
                                      demux_options_type
                                    ),
                                    b(str("targeted-distribution"),
                                        c(
                                            a(str("primary-list"), arg),
                                            a(str("backup-list"), arg),
                                            a(str("standby-list"), arg)
                                        )
                                    ),
                                    b(str("targeted-options"),
                                        c(
                                            b(str("weight"),
                                              (arg | arg)
                                            ),
                                            b(str("primary"),
                                              interface_device
                                            ),
                                            b(str("backup"),
                                              interface_device
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    c(
                                      b(str("keepalives"),
                                        keepalives_type
                                      ).as(:oneline),
                                      str("no-keepalives")
                                    ),
                                    str("inverse-arp"),
                                    a(str("transmit-weight"), arg),
                                    b(str("epd-threshold"),
                                      epd_threshold_config
                                    ).as(:oneline),
                                    a(str("cell-bundle-size"), arg),
                                    a(str("cell-bundle-timeout"), arg),
                                    str("plp-to-clp"),
                                    a(str("atm-scheduler-map"), arg),
                                    a(str("mrru"), arg),
                                    str("short-sequence"),
                                    a(str("fragment-threshold"), arg),
                                    a(str("drop-timeout"), arg),
                                    str("disable-mlppp-inner-ppp-pfc"),
                                    a(str("minimum-links"), arg),
                                    a(str("multilink-max-classes"), arg),
                                    b(str("compression"),
                                        c(
                                            b(str("rtp"),
                                                c(
                                                    a(str("f-max-period"), arg),
                                                    b(str("queues"),
                                                      (str("q0") | str("q1") | str("q2") | str("q3"))
                                                    ),
                                                    b(str("port"),
                                                        sc(
                                                            a(str("minimum"), arg),
                                                            a(str("maximum"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    b(str("maximum-contexts"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    str("interleave-fragments"),
                                    b(str("link-layer-overhead"),
                                      unsigned_float
                                    ),
                                    a(str("accounting-profile"), arg),
                                    a(str("peer-unit"), arg),
                                    b(str("tunnel"),
                                        c(
                                            b(str("encapsulation"),
                                                c(
                                                    b(str("vxlan-gpe"),
                                                        c(
                                                            b(str("source"),
                                                                c(
                                                                    b(str("address"),
                                                                      ipv4addr
                                                                    ),
                                                                    b(str("interface"),
                                                                      interface_name
                                                                    )
                                                                )
                                                            ),
                                                            b(str("destination"),
                                                                c(
                                                                    b(str("address"),
                                                                      ipv4addr
                                                                    )
                                                                )
                                                            ),
                                                            b(str("tunnel-endpoint"),
                                                              (str("vxlan"))
                                                            ),
                                                            a(str("destination-udp-port"), arg),
                                                            a(str("vni"), arg)
                                                        )
                                                    ),
                                                    b(str("udp"),
                                                        c(
                                                            b(str("source"),
                                                                c(
                                                                    b(str("address"),
                                                                      ipv4addr
                                                                    ),
                                                                    b(str("interface"),
                                                                      interface_name
                                                                    )
                                                                )
                                                            ),
                                                            b(str("destination"),
                                                                c(
                                                                    b(str("address"),
                                                                      ipv4addr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("source"),
                                              ipaddr
                                            ),
                                            b(str("destination"),
                                              ipaddr
                                            ),
                                            a(str("key"), arg),
                                            b(str("backup-destination"),
                                              ipaddr
                                            ),
                                            c(
                                              str("allow-fragmentation"),
                                              str("do-not-fragment")
                                            ),
                                            a(str("ttl"), arg),
                                            a(str("traffic-class"), arg),
                                            a(str("flow-label"), arg),
                                            str("path-mtu-discovery"),
                                            str("no-path-mtu-discovery"),
                                            b(str("routing-instance"),
                                                c(
                                                    a(str("destination"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("compression-device"),
                                      interface_unit
                                    ),
                                    b(str("atm-policer"),
                                        c(
                                            a(str("input-atm-policer"), arg)
                                        )
                                    ),
                                    b(str("layer2-policer"),
                                        c(
                                            c(
                                              a(str("input-policer"), arg),
                                              a(str("input-hierarchical-policer"), arg),
                                              a(str("input-three-color"), arg)
                                            ),
                                            c(
                                              b(str("output-policer"),
                                                (arg | arg)
                                              ),
                                              b(str("output-three-color"),
                                                (arg | arg)
                                              )
                                            )
                                        )
                                    ),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline)
                                            ),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    ),
                                    b(str("multi-chassis-protection"),
                                      multi_chassis_protection_group_ifl
                                    ),
                                    str("statistics"),
                                    b(str("esi"),
                                        c(
                                            b(str("auto-derive"),
                                                c(
                                                    c(
                                                      str("lacp")
                                                    )
                                                )
                                            ),
                                              esi,
                                            c(
                                              str("single-active"),
                                              str("all-active")
                                            ),
                                            b(str("df-election-type"),
                                                c(
                                                    c(
                                                      b(str("preference"),
                                                          c(
                                                              a(str("value"), arg)
                                                          )
                                                      )
                                                    ),
                                                    c(
                                                      str("mod")
                                                    )
                                                )
                                            ),
                                            b(str("source-bmac"),
                                              mac_unicast
                                            )
                                        )
                                    ),
                                    c(
                                      str("no-auto-virtual-gateway-esi"),
                                      b(str("virtual-gateway-esi"),
                                          c(
                                                esi,
                                              c(
                                                str("single-active"),
                                                str("all-active")
                                              )
                                          )
                                      )
                                    ),
                                    b(str("service"),
                                        c(
                                            b(a(str("pcef"), arg),
                                                c(
                                                    str("activate-all"),
                                                    a(str("activate"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    str("generate-eui64"),
                                    str("no-generate-eui64"),
                                    b(str("family"),
                                        c(
                                            b(str("inet"),
                                                c(
                                                    b(str("dhcp"),
                                                      dhcp_client_type
                                                    ),
                                                    b(str("targeted-broadcast"),
                                                        c(
                                                            c(
                                                              str("forward-and-send-to-re"),
                                                              str("forward-only")
                                                            )
                                                        )
                                                    ),
                                                    str("destination-class-usage"),
                                                    str("transit-options-packets"),
                                                    str("transit-ttl-exceeded"),
                                                    str("receive-options-packets"),
                                                    str("receive-ttl-exceeded"),
                                                    b(str("accounting"),
                                                        c(
                                                            b(str("source-class-usage"),
                                                                c(
                                                                    str("input"),
                                                                    str("output")
                                                                )
                                                            ),
                                                            str("destination-class-usage")
                                                        )
                                                    ),
                                                    b(str("mac-validate"),
                                                      (str("strict") | str("loose"))
                                                    ),
                                                    b(str("rpf-check"),
                                                        c(
                                                            a(str("fail-filter"), arg),
                                                            b(str("mode"),
                                                                sc(
                                                                    str("loose")
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    a(str("mtu"), arg),
                                                    a(str("arp-max-cache"), arg),
                                                    a(str("arp-new-hold-limit"), arg),
                                                    a(str("tcp-mss"), arg),
                                                    str("no-redirects"),
                                                    str("no-neighbor-learn"),
                                                    str("unconditional-src-learn"),
                                                    str("multicast-only"),
                                                    str("primary"),
                                                    a(str("ipsec-sa"), arg),
                                                    str("allow-filter-on-re"),
                                                    a(str("demux-source"), arg | arg),
                                                    a(str("demux-destination"), arg | arg),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              b(str("input"),
                                                                  sc(
                                                                      arg,
                                                                      a(str("shared-name"), arg),
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            a(str("input-chain"), arg),
                                                            a(str("output-chain"), arg),
                                                            c(
                                                              b(str("output"),
                                                                  sc(
                                                                      arg,
                                                                      a(str("shared-name"), arg),
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("output-list"), arg)
                                                            ),
                                                            b(str("adf"),
                                                                c(
                                                                    a(str("rule"), arg),
                                                                    str("counter"),
                                                                    a(str("input-precedence"), arg),
                                                                    str("not-mandatory"),
                                                                    a(str("output-precedence"), arg)
                                                                )
                                                            ),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    b(str("ingress-queuing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    b(str("iq-policing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    b(str("simple-filter"),
                                                        c(
                                                            a(str("input"), arg)
                                                        )
                                                    ),
                                                    a(str("input-hierarchical-policer"), arg),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("arp"), arg),
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    ),
                                                    b(str("sampling"),
                                                        c(
                                                            str("input"),
                                                            str("output")
                                                        )
                                                    ),
                                                    b(str("service"),
                                                        c(
                                                            b(str("input"),
                                                                c(
                                                                    b(a(str("service-set"), arg),
                                                                        c(
                                                                            a(str("service-filter"), arg)
                                                                        )
                                                                    ),
                                                                    a(str("post-service-filter"), arg)
                                                                )
                                                            ),
                                                            b(str("output"),
                                                                c(
                                                                    b(a(str("service-set"), arg),
                                                                        c(
                                                                            a(str("service-filter"), arg)
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(a(str("next-hop-tunnel"), arg),
                                                        c(
                                                            a(str("ipsec-vpn"), arg)
                                                        )
                                                    ),
                                                    b(a(str("address"), arg),
                                                        c(
                                                            b(str("destination"),
                                                              ipv4addr
                                                            ),
                                                            a(str("destination-profile"), arg),
                                                            b(str("broadcast"),
                                                              ipv4addr
                                                            ),
                                                            str("primary"),
                                                            str("preferred"),
                                                            str("master-only"),
                                                            b(a(str("multipoint-destination"), arg),
                                                                c(
                                                                    c(
                                                                      a(str("dlci"), arg),
                                                                      b(str("vci"),
                                                                        atm_vci
                                                                      )
                                                                    ),
                                                                    b(str("shaping"),
                                                                      dcd_shaping_config
                                                                    ),
                                                                    b(str("oam-period"),
                                                                        sc(
                                                                            ca(
                                                                              str("disable").as(:oneline)
                                                                            )
                                                                        )
                                                                    ).as(:oneline),
                                                                    b(str("oam-liveness"),
                                                                        c(
                                                                            a(str("up-count"), arg),
                                                                            a(str("down-count"), arg)
                                                                        )
                                                                    ),
                                                                    str("inverse-arp"),
                                                                    a(str("transmit-weight"), arg),
                                                                    b(str("epd-threshold"),
                                                                      epd_threshold_config
                                                                    ).as(:oneline)
                                                                )
                                                            ),
                                                            b(a(str("arp"), arg),
                                                                sc(
                                                                    b(str("l2-interface"),
                                                                      interface_name
                                                                    ),
                                                                    c(
                                                                      b(str("mac"),
                                                                        mac_unicast
                                                                      ),
                                                                      b(str("multicast-mac"),
                                                                        mac_multicast
                                                                      )
                                                                    ),
                                                                    str("publish")
                                                                )
                                                            ).as(:oneline),
                                                            b(a(str("host-discovery"), arg),
                                                                sc(
                                                                    a(str("aging-timer"), arg),
                                                                    a(str("discovery-interval"), arg)
                                                                )
                                                            ).as(:oneline),
                                                            b(str("web-authentication"),
                                                                c(
                                                                    str("https"),
                                                                    str("http"),
                                                                    str("redirect-to-https")
                                                                )
                                                            ),
                                                            b(str("vrrp-group"),
                                                              vrrp_group
                                                            ),
                                                            b(str("virtual-gateway-address"),
                                                              ipv4addr
                                                            )
                                                        )
                                                    ),
                                                    b(str("unnumbered-address"),
                                                        sc(
                                                              interface_unit,
                                                            b(str("preferred-source-address"),
                                                              (arg | arg)
                                                            ),
                                                            b(str("destination"),
                                                              ipv4addr
                                                            ),
                                                            a(str("destination-profile"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    b(str("location-pool-address"),
                                                        c(
                                                              arg
                                                        )
                                                    ),
                                                    str("negotiate-address"),
                                                    a(str("destination-udp-port"), arg)
                                                )
                                            ),
                                            b(str("iso"),
                                                c(
                                                    a(str("address"), arg),
                                                    a(str("mtu"), arg),
                                                    a(str("destination-udp-port"), arg)
                                                )
                                            ),
                                            b(str("inet6"),
                                                c(
                                                    b(str("dhcpv6-client"),
                                                        c(
                                                            b(str("client-type"),
                                                              (str("stateful") | str("autoconfig"))
                                                            ),
                                                            a(str("client-ia-type"), enum(str("ia-na") | str("ia-pd"))),
                                                            str("rapid-commit"),
                                                            b(str("prefix-delegating"),
                                                                c(
                                                                    a(str("preferred-prefix-length"), arg),
                                                                    a(str("sub-prefix-length"), arg)
                                                                )
                                                            ),
                                                            b(str("client-identifier"),
                                                                sc(
                                                                    b(str("duid-type"),
                                                                      (str("duid-llt") | str("vendor") | str("duid-ll"))
                                                                    )
                                                                )
                                                            ).as(:oneline),
                                                            a(str("req-option"), enum(str("dns-server") | str("domain") | str("ntp-server") | str("time-zone") | str("sip-server") | str("sip-domain") | str("nis-server") | str("nis-domain") | str("fqdn") | str("vendor-spec") | str("zero-touch-redirect"))),
                                                            b(str("options"),
                                                                c(
                                                                    b(a(str("number"), arg),
                                                                        sc(
                                                                            c(
                                                                              a(str("hex-string"), arg)
                                                                            )
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            ),
                                                            a(str("retransmission-attempt"), arg),
                                                            str("no-dns-install"),
                                                            b(str("update-router-advertisement"),
                                                                c(
                                                                    b(a(str("interface"), arg),
                                                                        c(
                                                                            str("managed-configuration"),
                                                                            str("no-managed-configuration"),
                                                                            str("other-stateful-configuration"),
                                                                            str("no-other-stateful-configuration"),
                                                                            a(str("max-advertisement-interval"), arg),
                                                                            a(str("min-advertisement-interval"), arg),
                                                                            str("enable-recursive-dns-server-option"),
                                                                            str("no-enable-recursive-dns-server-option")
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            str("update-server")
                                                        )
                                                    ),
                                                    b(str("rpf-check"),
                                                        c(
                                                            a(str("fail-filter"), arg),
                                                            b(str("mode"),
                                                                sc(
                                                                    str("loose")
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    b(str("accounting"),
                                                        c(
                                                            b(str("source-class-usage"),
                                                                c(
                                                                    str("input"),
                                                                    str("output")
                                                                )
                                                            ),
                                                            str("destination-class-usage")
                                                        )
                                                    ),
                                                    a(str("mtu"), arg),
                                                    a(str("tcp-mss"), arg),
                                                    a(str("nd6-stale-time"), arg),
                                                    str("no-neighbor-learn"),
                                                    str("slaac-enable"),
                                                    b(str("ndp-proxy"),
                                                        c(
                                                            str("interface-restricted")
                                                        )
                                                    ),
                                                    b(str("dad-proxy"),
                                                        c(
                                                            str("interface-restricted")
                                                        )
                                                    ),
                                                    a(str("nd6-max-cache"), arg),
                                                    a(str("nd6-new-hold-limit"), arg),
                                                    str("no-redirects"),
                                                    str("allow-filter-on-re"),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              b(str("input"),
                                                                  sc(
                                                                      arg,
                                                                      a(str("shared-name"), arg),
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            c(
                                                              b(str("output"),
                                                                  sc(
                                                                      arg,
                                                                      a(str("shared-name"), arg),
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("output-list"), arg)
                                                            ),
                                                            a(str("input-chain"), arg),
                                                            a(str("output-chain"), arg),
                                                            b(str("adf"),
                                                                c(
                                                                    a(str("rule"), arg),
                                                                    str("counter"),
                                                                    a(str("input-precedence"), arg),
                                                                    str("not-mandatory"),
                                                                    a(str("output-precedence"), arg)
                                                                )
                                                            ),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    b(str("ingress-queuing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    a(str("input-hierarchical-policer"), arg),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    ),
                                                    b(str("sampling"),
                                                        c(
                                                            str("input"),
                                                            str("output")
                                                        )
                                                    ),
                                                    b(str("service"),
                                                        c(
                                                            b(str("input"),
                                                                c(
                                                                    b(a(str("service-set"), arg),
                                                                        c(
                                                                            a(str("service-filter"), arg)
                                                                        )
                                                                    ),
                                                                    a(str("post-service-filter"), arg)
                                                                )
                                                            ),
                                                            b(str("output"),
                                                                c(
                                                                    b(a(str("service-set"), arg),
                                                                        c(
                                                                            a(str("service-filter"), arg)
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(a(str("address"), arg),
                                                        c(
                                                            b(str("destination"),
                                                              ipv6addr
                                                            ),
                                                            str("eui-64"),
                                                            str("primary"),
                                                            str("preferred"),
                                                            str("master-only"),
                                                            b(a(str("ndp"), arg),
                                                                sc(
                                                                    b(str("l2-interface"),
                                                                      interface_name
                                                                    ),
                                                                    c(
                                                                      b(str("mac"),
                                                                        mac_unicast
                                                                      ),
                                                                      b(str("multicast-mac"),
                                                                        mac_multicast
                                                                      )
                                                                    ),
                                                                    str("publish")
                                                                )
                                                            ).as(:oneline),
                                                            b(str("vrrp-inet6-group"),
                                                              vrrp_group
                                                            ),
                                                            b(str("web-authentication"),
                                                                c(
                                                                    str("https"),
                                                                    str("http"),
                                                                    str("redirect-to-https")
                                                                )
                                                            ),
                                                            b(str("virtual-gateway-address"),
                                                              ipv6addr
                                                            ),
                                                            str("subnet-router-anycast")
                                                        )
                                                    ),
                                                    a(str("demux-source"), arg | arg | arg),
                                                    a(str("demux-destination"), arg | arg),
                                                    b(str("unnumbered-address"),
                                                        sc(
                                                              interface_unit,
                                                            b(str("preferred-source-address"),
                                                              (arg | arg)
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    str("dad-disable"),
                                                    str("no-dad-disable"),
                                                    a(str("destination-udp-port"), arg)
                                                )
                                            ),
                                            b(str("mpls"),
                                                c(
                                                    a(str("mtu"), arg),
                                                    a(str("maximum-labels"), arg),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              a(str("input"), arg),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            a(str("input-chain"), arg),
                                                            c(
                                                              a(str("output"), arg),
                                                              a(str("output-list"), arg)
                                                            ),
                                                            a(str("output-chain"), arg),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    b(str("ingress-queuing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    a(str("input-hierarchical-policer"), arg),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    ),
                                                    a(str("destination-udp-port"), arg)
                                                )
                                            ),
                                            b(str("mlppp"),
                                                c(
                                                    b(str("bundle"),
                                                      (arg | arg)
                                                    ),
                                                    c(
                                                      b(str("service-interface"),
                                                        interface_device
                                                      ),
                                                      a(str("service-device-pool"), arg)
                                                    ),
                                                    a(str("dynamic-profile"), arg)
                                                )
                                            ),
                                            b(str("mlfr-end-to-end"),
                                                c(
                                                    b(str("bundle"),
                                                      interface_unit
                                                    )
                                                )
                                            ),
                                            b(str("mlfr-uni-nni"),
                                                c(
                                                    b(str("bundle"),
                                                      interface_unit
                                                    )
                                                )
                                            ),
                                            b(str("ccc"),
                                                c(
                                                    a(str("mtu"), arg),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              a(str("input"), arg),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            a(str("input-chain"), arg),
                                                            c(
                                                              a(str("output"), arg),
                                                              a(str("output-list"), arg)
                                                            ),
                                                            a(str("output-chain"), arg),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    b(str("ingress-queuing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    ),
                                                    str("translate-fecn-and-becn"),
                                                    c(
                                                      str("translate-discard-eligible"),
                                                      str("translate-plp-control-word-de")
                                                    ),
                                                    str("keep-address-and-control")
                                                )
                                            ),
                                            b(str("tcc"),
                                                c(
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    ),
                                                    b(str("proxy"),
                                                        c(
                                                            b(str("inet-address"),
                                                              ipv4addr
                                                            )
                                                        )
                                                    ),
                                                    b(str("remote"),
                                                        c(
                                                            b(str("inet-address"),
                                                              ipv4addr
                                                            ),
                                                            b(str("mac-address"),
                                                              mac_addr
                                                            )
                                                        )
                                                    ),
                                                    b(str("protocols"),
                                                      (str("mpls") | str("inet") | str("iso"))
                                                    )
                                                )
                                            ),
                                            b(str("vpls"),
                                                c(
                                                    str("core-facing"),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              b(str("input"),
                                                                  sc(
                                                                      arg,
                                                                      a(str("shared-name"), arg),
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            a(str("input-chain"), arg),
                                                            a(str("output-chain"), arg),
                                                            c(
                                                              b(str("output"),
                                                                  sc(
                                                                      arg,
                                                                      a(str("shared-name"), arg),
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("output-list"), arg)
                                                            ),
                                                            b(str("adf"),
                                                                c(
                                                                    a(str("rule"), arg),
                                                                    str("counter"),
                                                                    a(str("input-precedence"), arg),
                                                                    str("not-mandatory"),
                                                                    a(str("output-precedence"), arg)
                                                                )
                                                            ),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    b(str("ingress-queuing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    b(str("iq-policing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    ),
                                                    b(str("sampling"),
                                                        c(
                                                            str("input"),
                                                            str("output")
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("bridge"),
                                                c(
                                                    str("core-facing"),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              b(str("input"),
                                                                  sc(
                                                                      arg,
                                                                      a(str("shared-name"), arg),
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            a(str("input-chain"), arg),
                                                            a(str("output-chain"), arg),
                                                            c(
                                                              b(str("output"),
                                                                  sc(
                                                                      arg,
                                                                      a(str("shared-name"), arg),
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("output-list"), arg)
                                                            ),
                                                            b(str("adf"),
                                                                c(
                                                                    a(str("rule"), arg),
                                                                    str("counter"),
                                                                    a(str("input-precedence"), arg),
                                                                    str("not-mandatory"),
                                                                    a(str("output-precedence"), arg)
                                                                )
                                                            ),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    b(str("ingress-queuing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    b(str("iq-policing-filter"),
                                                        sc(
                                                            arg
                                                        )
                                                    ).as(:oneline),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    ),
                                                    b(str("interface-mode"),
                                                      (str("access") | str("trunk"))
                                                    ),
                                                    str("vlan-auto-sense"),
                                                    b(str("bridge-domain-type"),
                                                      (str("svlan") | str("bvlan"))
                                                    ),
                                                    str("inter-switch-link"),
                                                    c(
                                                      a(str("vlan-id"), arg),
                                                      a(str("vlan-id-list"), arg),
                                                      a(str("inner-vlan-id-list"), arg)
                                                    ),
                                                    b(str("vlan-rewrite"),
                                                        c(
                                                            b(a(str("translate"), arg),
                                                                sc(
                                                                      arg
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    c(
                                                      b(str("isid-list"),
                                                        (str("all-service-groups") | str("all"))
                                                      )
                                                    ),
                                                    b(str("storm-control"),
                                                        c(
                                                            arg
                                                        )
                                                    ),
                                                    b(str("recovery-timeout"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline),
                                                    b(str("sampling"),
                                                        c(
                                                            str("input"),
                                                            str("output")
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("ethernet-switching"),
                                              ethernet_switching_type
                                            ),
                                            b(str("fibre-channel"),
                                              fibre_channel_type
                                            ),
                                            b(str("pppoe"),
                                              pppoe_underlying_options_type
                                            ),
                                            b(str("any"),
                                                c(
                                                    b(str("filter"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("group"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("service-domain"),
                                      (str("inside") | str("outside"))
                                    ),
                                    str("copy-tos-to-outer-ip-header"),
                                    str("copy-tos-to-outer-ip-header-transit"),
                                    str("force-control-packets-on-transit-path"),
                                    b(str("load-balancing-options"),
                                        c(
                                            b(str("preferred-active"),
                                              interface_device
                                            ),
                                            str("disable-hash"),
                                            b(str("hash-keys"),
                                                c(
                                                    b(str("ingress-key"),
                                                          enum((str("source-ip") | str("destination-ip") | str("protocol") | str("iif")))
                                                    ),
                                                    b(str("egress-key"),
                                                          enum((str("source-ip") | str("destination-ip") | str("protocol") | str("oif")))
                                                    ),
                                                    b(str("ipv6-source-prefix-length"),
                                                      (str("56") | str("64") | str("96") | str("128"))
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("mac"),
                                      mac_unicast
                                    ),
                                    b(str("virtual-gateway-v4-mac"),
                                      mac_unicast
                                    ),
                                    b(str("virtual-gateway-v6-mac"),
                                      mac_unicast
                                    ),
                                    b(str("forwarding-options"),
                                        c(
                                            b(str("load-balance-stateful"),
                                                c(
                                                    str("per-flow"),
                                                    a(str("rebalance"), arg),
                                                    b(str("load-type"),
                                                      (str("high") | str("medium") | str("low"))
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("etree-ac-role"),
                                      (str("root") | str("leaf"))
                                    )
                                )
                            ),
                            b(str("no-partition"),
                                sc(
                                    b(str("interface-type"),
                                      (str("e1") | str("t1") | str("at") | str("t3") | str("e3") | str("ct3") | str("so") | str("cau4"))
                                    )
                                )
                            ).as(:oneline),
                            b(a(str("partition"), arg),
                                sc(
                                    a(str("oc-slice"), arg),
                                    a(str("timeslots"), arg),
                                    b(str("interface-type"),
                                      (str("ds") | str("e1") | str("t1") | str("at") | str("ct1") | str("ce1") | str("t3") | str("ct3") | str("e3") | str("so") | str("coc1") | str("cau4") | str("dc") | str("bc"))
                                    )
                                )
                            ).as(:oneline),
                            b(str("radius-options"),
                              radius_options_vlan_type
                            )
                        )
                    ),
                      interfaces_type
                )
            ),
            b(a(str("logical-systems"), arg),
                c(
                    b(str("interfaces"),
                        c(
                            b(a(str("pic-set"), arg),
                                c(
                                    a(str("interface"), arg),
                                    b(a(str("fpc"), arg),
                                        c(
                                            a(str("pic"), arg)
                                        )
                                    )
                                )
                            ),
                            a(str("interface-set"), arg | arg | arg | arg | arg | arg,
                                c(
                                    str("targeted-distribution"),
                                    b(str("targeted-options"),
                                        c(
                                            b(str("weight"),
                                              (arg | arg)
                                            )
                                        )
                                    ),
                                    b(a(str("interface"), arg),
                                        c(
                                            a(str("unit"), arg),
                                            a(str("vlan-tags-outer"), arg)
                                        )
                                    ),
                                    b(str("pppoe-underlying-options"),
                                      pppoe_underlying_options_type
                                    )
                                )
                            ),
                            b(str("stacked-interface-set"),
                                c(
                                    a(str("interface-set"), arg | arg,
                                        c(
                                            a(str("interface-set"), arg | arg | arg | arg | arg | arg)
                                        )
                                    )
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("all") | str("kernel") | str("change-events") | str("kernel-detail") | str("config-states") | str("resource-usage") | str("gres-events") | str("select-events") | str("bfd-events") | str("lib-events") | str("reserved") | str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("informational") | str("debugging") | str("verbose") | str("japi")),
                                        sc(
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(a(str("interface-range"), arg),
                                c(
                                    a(str("member"), arg),
                                    b(a(str("member-range"), arg),
                                        sc(
                                            b(str("end-range"),
                                              interface_device
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("description"), quote | arg),
                                    a(str("external-model-name"), arg),
                                    a(str("metadata"), arg),
                                      (str("disable")),
                                    str("promiscuous-mode"),
                                    a(str("port-mirror-instance"), arg),
                                    str("multicast-statistics"),
                                    str("oam-on-svlan"),
                                    b(str("fabric-options"),
                                        c(
                                            a(str("member-interfaces"), arg),
                                            b(str("remote-chassis"),
                                                c(
                                                    b(str("destination"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), enum(str("ipc") | str("event") | str("media") | str("all"))).as(:oneline)
                                        )
                                    ),
                                    str("passive-monitor-mode"),
                                    c(
                                      b(str("keepalives"),
                                        keepalives_type
                                      ).as(:oneline),
                                      str("no-keepalives")
                                    ),
                                    str("traps"),
                                    str("no-traps"),
                                    str("interface-mib"),
                                    str("no-interface-mib"),
                                    a(str("accounting-profile"), arg),
                                    b(str("anchor-point"),
                                        c(
                                              interface_device
                                        )
                                    ),
                                    str("bypass-queueing-chip"),
                                    str("no-bypass-queueing-chip"),
                                    c(
                                      str("per-unit-scheduler"),
                                      str("no-per-unit-scheduler"),
                                      str("shared-scheduler"),
                                      b(str("hierarchical-scheduler"),
                                          sc(
                                              a(str("maximum-hierarchy-levels"), arg),
                                              a(str("maximum-l2-nodes"), arg),
                                              a(str("maximum-l3-nodes"), arg),
                                              str("implicit-hierarchy")
                                          )
                                      ).as(:oneline)
                                    ),
                                    a(str("l2tp-maximum-session"), arg),
                                    a(str("schedulers"), arg),
                                    str("interface-transmit-statistics"),
                                    str("cascade-port"),
                                    str("dce"),
                                    c(
                                      str("vlan-tagging"),
                                      str("stacked-vlan-tagging"),
                                      str("flexible-vlan-tagging"),
                                      str("vlan-vci-tagging")
                                    ),
                                    str("hybrid-access"),
                                    a(str("native-vlan-id"), arg),
                                    str("no-native-vlan-insert"),
                                    str("vlan-offload"),
                                    b(str("input-native-vlan-push"),
                                      (str("disable") | str("enable"))
                                    ),
                                    str("no-pseudowire-down-on-core-isolation"),
                                    b(str("speed"),
                                      (str("auto") | str("auto-10m-100m") | str("10m") | str("100m") | str("1g") | str("2.5g") | str("5g") | str("10g") | str("40g") | str("oc3") | str("oc12") | str("oc48"))
                                    ),
                                    b(str("forwarding-class-accounting"),
                                        c(
                                            b(str("direction"),
                                              (str("ingress") | str("egress") | str("both"))
                                            ),
                                            b(str("enhanced"),
                                                c(
                                                    b(str("traffic-type"),
                                                      (str("unicast-statistics") | str("multicast-statistics"))
                                                    ),
                                                    b(str("family"),
                                                      (str("inet6") | str("inet") | str("both"))
                                                    ),
                                                    b(str("direction"),
                                                      (str("ingress") | str("egress") | str("both"))
                                                    ),
                                                    a(str("overhead-bytes"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("auto-configure"),
                                      auto_configure_vlan_type
                                    ),
                                    a(str("mtu"), arg),
                                    b(str("hold-time"),
                                        sc(
                                            a(str("up"), arg),
                                            a(str("down"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("damping"),
                                        c(
                                            a(str("half-life"), arg),
                                            a(str("max-suppress"), arg),
                                            a(str("reuse"), arg),
                                            a(str("suppress"), arg),
                                            str("enable")
                                        )
                                    ),
                                    b(str("link-degrade-monitor"),
                                        c(
                                            b(str("actions"),
                                                c(
                                                    c(
                                                      str("media-based")
                                                    )
                                                )
                                            ),
                                            b(str("recovery"),
                                                c(
                                                    a(str("timer"), arg),
                                                    c(
                                                      str("auto"),
                                                      str("manual")
                                                    )
                                                )
                                            ),
                                            b(str("thresholds"),
                                                c(
                                                    a(str("set"), arg),
                                                    a(str("clear"), arg),
                                                    a(str("warning-set"), arg),
                                                    a(str("warning-clear"), arg),
                                                    a(str("interval"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("satop-options"),
                                        c(
                                            a(str("idle-pattern"), arg),
                                            a(str("payload-size"), arg),
                                            b(str("excessive-packet-loss-rate"),
                                                c(
                                                    a(str("threshold"), arg),
                                                    a(str("sample-period"), arg)
                                                )
                                            ),
                                            c(
                                              a(str("jitter-buffer-packets"), arg),
                                              a(str("jitter-buffer-latency"), arg),
                                              str("jitter-buffer-auto-adjust")
                                            ),
                                            a(str("bit-rate"), arg)
                                        )
                                    ),
                                    b(str("cesopsn-options"),
                                        c(
                                            a(str("idle-pattern"), arg),
                                            a(str("packetization-latency"), arg),
                                            a(str("payload-size"), arg),
                                            b(str("excessive-packet-loss-rate"),
                                                c(
                                                    a(str("threshold"), arg),
                                                    a(str("sample-period"), arg)
                                                )
                                            ),
                                            c(
                                              a(str("jitter-buffer-packets"), arg),
                                              a(str("jitter-buffer-latency"), arg),
                                              str("jitter-buffer-auto-adjust")
                                            ),
                                            a(str("bit-rate"), arg)
                                        )
                                    ),
                                    b(str("ima-group-options"),
                                        c(
                                            b(str("frame-length"),
                                              (str("32") | str("64") | str("128") | str("256"))
                                            ),
                                            b(str("symmetry"),
                                              (str("symmetrical-config-and-operation") | str("symmetrical-config-asymmetrical-operation"))
                                            ),
                                            b(str("transmit-clock"),
                                              (str("common") | str("independent"))
                                            ),
                                            b(str("version"),
                                              (str("1.0") | str("1.1"))
                                            ),
                                            b(str("minimum-links"),
                                                c(
                                                    c(
                                                        arg
                                                    )
                                                )
                                            ),
                                            b(str("frame-synchronization"),
                                                c(
                                                    a(str("alpha"), arg),
                                                    a(str("beta"), arg),
                                                    a(str("gamma"), arg)
                                                )
                                            ),
                                            b(str("test-procedure"),
                                                c(
                                                    a(str("period"), arg),
                                                    b(str("interface"),
                                                      interface_device
                                                    ),
                                                    a(str("pattern"), arg)
                                                )
                                            ),
                                            a(str("differential-delay"), arg)
                                        )
                                    ),
                                    b(str("ima-link-options"),
                                        c(
                                            a(str("group-id"), arg)
                                        )
                                    ),
                                    b(str("multi-chassis-protection"),
                                      multi_chassis_protection_group
                                    ),
                                    b(str("clocking"),
                                        sc(
                                            c(
                                              str("internal"),
                                              str("external")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("link-mode"),
                                      (str("automatic") | str("half-duplex") | str("full-duplex"))
                                    ),
                                    b(str("media-type"),
                                      (str("copper") | str("fiber"))
                                    ),
                                    b(str("encapsulation"),
                                      (str("ethernet-ccc") | str("fddi") | str("token-ring") | str("ppp") | str("ppp-ccc") | str("ppp-tcc") | str("ether-vpls-ppp") | str("frame-relay") | str("frame-relay-ccc") | str("frame-relay-tcc") | str("extended-frame-relay-ccc") | str("extended-frame-relay-tcc") | str("flexible-frame-relay") | str("frame-relay-port-ccc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("extended-frame-relay-ether-type-tcc") | str("cisco-hdlc") | str("cisco-hdlc-ccc") | str("cisco-hdlc-tcc") | str("vlan-ccc") | str("extended-vlan-ccc") | str("ethernet-tcc") | str("flexible-ethernet-services") | str("smds-dxi") | str("atm-pvc") | str("atm-ccc-cell-relay") | str("ethernet-over-atm") | str("ethernet-vpls") | str("extended-vlan-tcc") | str("multilink-frame-relay-uni-nni") | str("satop") | str("cesopsn") | str("ima") | str("ethernet-bridge") | str("ethernet") | str("vlan-vpls") | str("vlan-vci-ccc") | str("extended-vlan-vpls") | str("extended-vlan-bridge") | str("multilink-ppp") | str("generic-services"))
                                    ),
                                    b(str("esi"),
                                        c(
                                            b(str("auto-derive"),
                                                c(
                                                    c(
                                                      str("lacp")
                                                    )
                                                )
                                            ),
                                              esi,
                                            c(
                                              str("single-active"),
                                              str("all-active")
                                            ),
                                            b(str("df-election-type"),
                                                c(
                                                    c(
                                                      b(str("preference"),
                                                          c(
                                                              a(str("value"), arg)
                                                          )
                                                      )
                                                    ),
                                                    c(
                                                      str("mod")
                                                    )
                                                )
                                            ),
                                            b(str("source-bmac"),
                                              mac_unicast
                                            )
                                        )
                                    ),
                                    b(str("framing"),
                                        c(
                                            c(
                                              str("lan-phy"),
                                              str("wan-phy"),
                                              str("sonet"),
                                              str("sdh")
                                            ),
                                            str("precise-bandwidth")
                                        )
                                    ),
                                    str("unidirectional"),
                                    b(str("lmi"),
                                        c(
                                            a(str("n391dte"), arg),
                                            a(str("n392dce"), arg),
                                            a(str("n392dte"), arg),
                                            a(str("n393dce"), arg),
                                            a(str("n393dte"), arg),
                                            a(str("t391dte"), arg),
                                            a(str("t392dce"), arg),
                                            b(str("lmi-type"),
                                              (str("ansi") | str("itu") | str("c-lmi"))
                                            )
                                        )
                                    ),
                                    b(str("mlfr-uni-nni-bundle-options"),
                                        c(
                                            b(str("cisco-interoperability"),
                                                c(
                                                    str("send-lip-remove-link-for-link-reject")
                                                )
                                            ),
                                            a(str("mrru"), arg),
                                            a(str("yellow-differential-delay"), arg),
                                            a(str("red-differential-delay"), arg),
                                            b(str("action-red-differential-delay"),
                                              (str("remove-link") | str("disable-tx"))
                                            ),
                                            a(str("fragment-threshold"), arg),
                                            a(str("drop-timeout"), arg),
                                            b(str("link-layer-overhead"),
                                              unsigned_float
                                            ),
                                            b(str("lmi-type"),
                                              (str("ansi") | str("itu") | str("c-lmi"))
                                            ),
                                            a(str("minimum-links"), arg),
                                            a(str("hello-timer"), arg),
                                            a(str("acknowledge-timer"), arg),
                                            a(str("acknowledge-retries"), arg),
                                            a(str("n391"), arg),
                                            a(str("n392"), arg),
                                            a(str("n393"), arg),
                                            a(str("t391"), arg),
                                            a(str("t392"), arg)
                                        )
                                    ),
                                    b(str("mac"),
                                      mac_unicast
                                    ),
                                    b(str("receive-bucket"),
                                      dcd_rx_bucket_config
                                    ),
                                    b(str("transmit-bucket"),
                                      dcd_tx_bucket_config
                                    ),
                                    str("shared-interface"),
                                    b(str("sonet-options"),
                                      sonet_options_type
                                    ),
                                    b(str("logical-tunnel-options"),
                                        c(
                                            b(str("link-protection"),
                                                c(
                                                    str("revertive"),
                                                    str("non-revertive")
                                                )
                                            ),
                                            str("per-unit-mac-disable"),
                                            b(str("load-balance"),
                                              aggregate_load_balance
                                            )
                                        )
                                    ),
                                    b(str("aggregated-sonet-options"),
                                        c(
                                            a(str("minimum-links"), arg),
                                            b(str("link-speed"),
                                              (str("oc3") | str("oc12") | str("oc48") | str("oc192") | str("oc768") | str("mixed"))
                                            ),
                                            a(str("minimum-bandwidth"), arg)
                                        )
                                    ),
                                    b(str("atm-options"),
                                        c(
                                            b(str("pic-type"),
                                              (str("atm-ce") | str("atm2") | str("atm1"))
                                            ),
                                            a(str("cell-bundle-size"), arg),
                                            a(str("cell-bundle-timeout"), arg),
                                            str("plp-to-clp"),
                                            str("use-null-cw"),
                                            b(str("promiscuous-mode"),
                                                c(
                                                    a(str("vpi"), arg).as(:oneline)
                                                )
                                            ),
                                            b(a(str("vpi"), arg),
                                                c(
                                                    a(str("maximum-vcs"), arg),
                                                    b(str("shaping"),
                                                      dcd_shaping_config
                                                    ),
                                                    b(str("oam-period"),
                                                        sc(
                                                            ca(
                                                              str("disable").as(:oneline)
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    b(str("oam-liveness"),
                                                        c(
                                                            a(str("up-count"), arg),
                                                            a(str("down-count"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            str("ilmi"),
                                            b(a(str("linear-red-profiles"), arg),
                                                sc(
                                                    a(str("queue-depth"), arg),
                                                    a(str("high-plp-threshold"), arg),
                                                    a(str("low-plp-threshold"), arg),
                                                    a(str("high-plp-max-threshold"), arg),
                                                    a(str("low-plp-max-threshold"), arg)
                                                )
                                            ).as(:oneline),
                                            b(a(str("scheduler-maps"), arg),
                                                c(
                                                    b(str("vc-cos-mode"),
                                                      (str("strict") | str("alternate"))
                                                    ),
                                                    b(a(str("forwarding-class"), arg),
                                                        c(
                                                            b(str("priority"),
                                                              (str("low") | str("high"))
                                                            ),
                                                            b(str("transmit-weight"),
                                                                sc(
                                                                    c(
                                                                      a(str("percent"), arg),
                                                                      a(str("cells"), arg)
                                                                    )
                                                                )
                                                            ).as(:oneline),
                                                            c(
                                                              b(str("epd-threshold"),
                                                                epd_threshold_config
                                                              ).as(:oneline),
                                                              a(str("linear-red-profile"), arg)
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("mpls"),
                                              mpls_ifd_options
                                            ),
                                            str("payload-scrambler"),
                                            str("no-payload-scrambler")
                                        )
                                    ),
                                    b(str("multiservice-options"),
                                        c(
                                            str("syslog"),
                                            str("no-syslog"),
                                            str("core-dump"),
                                            str("no-core-dump"),
                                            str("dump-on-flow-control"),
                                            str("no-dump-on-flow-control"),
                                            str("reset-on-flow-control"),
                                            str("no-reset-on-flow-control"),
                                            b(str("flow-control-options"),
                                                c(
                                                    str("dump-on-flow-control"),
                                                    str("reset-on-flow-control"),
                                                    str("down-on-flow-control"),
                                                    str("up-on-flow-control")
                                                )
                                            )
                                        )
                                    ),
                                    b(str("ggsn-options"),
                                        c(
                                            str("syslog"),
                                            str("no-syslog"),
                                            str("core-dump"),
                                            str("no-core-dump")
                                        )
                                    ),
                                    b(str("ppp-options"),
                                      ppp_options_type
                                    ),
                                    b(str("redundancy-options"),
                                        c(
                                            b(str("primary"),
                                              interface_device
                                            ),
                                            b(str("secondary"),
                                              interface_device
                                            ),
                                            b(str("redundancy-peer"),
                                                c(
                                                    b(str("ipaddress"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("redundancy-local"),
                                                c(
                                                    b(str("data-address"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            a(str("routing-instance"), arg),
                                            a(str("replication-threshold"), arg),
                                            b(str("replication-options"),
                                                c(
                                                    a(str("mtu"), arg)
                                                )
                                            ),
                                            b(str("replicate-services"),
                                                c(
                                                    str("pgcp")
                                                )
                                            )
                                        )
                                    ),
                                    b(str("load-balancing-options"),
                                        c(
                                            a(str("member-interface"), arg),
                                            b(str("member-failure-options"),
                                                c(
                                                    c(
                                                      b(str("redistribute-all-traffic"),
                                                          c(
                                                              str("enable-rejoin")
                                                          )
                                                      ),
                                                      b(str("drop-member-traffic"),
                                                          c(
                                                              a(str("rejoin-timeout"), arg),
                                                              str("enable-rejoin")
                                                          )
                                                      )
                                                    )
                                                )
                                            ),
                                            b(str("high-availability-options"),
                                                c(
                                                    c(
                                                      b(str("many-to-one"),
                                                          c(
                                                              b(str("preferred-backup"),
                                                                interface_device
                                                              )
                                                          )
                                                      ),
                                                      b(str("one-to-one"),
                                                          c(
                                                              b(str("preferred-backup"),
                                                                interface_device
                                                              )
                                                          )
                                                      )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("aggregated-inline-services-options"),
                                        c(
                                            b(str("primary-interface"),
                                              interface_device
                                            ),
                                            b(str("secondary-interface"),
                                              interface_device
                                            )
                                        )
                                    ),
                                    b(str("anchoring-options"),
                                        c(
                                            a(str("apfe-group-set"), arg),
                                            a(str("primary-list"), arg),
                                            b(str("secondary"),
                                                c(
                                                    arg
                                                )
                                            ),
                                            c(
                                              str("warm-standby")
                                            )
                                        )
                                    ),
                                    b(str("lsq-failure-options"),
                                        c(
                                            a(str("trigger-link-failure"), arg),
                                            str("no-termination-request"),
                                            str("no-no-termination-request")
                                        )
                                    ),
                                    b(str("redundancy-group"),
                                        c(
                                            b(a(str("member-interface"), arg),
                                                c(
                                                    c(
                                                      str("active"),
                                                      str("backup")
                                                    )
                                                )
                                            ),
                                            a(str("maximum-links"), arg)
                                        )
                                    ),
                                    b(str("services-options"),
                                        c(
                                            b(str("syslog"),
                                              log_object
                                            ),
                                            b(str("jflow-log"),
                                                c(
                                                    a(str("message-rate-limit"), arg)
                                                )
                                            ),
                                            b(str("deterministic-nat-configuration-log-interval"),
                                                c(
                                                    a(str("interval"), arg)
                                                )
                                            ),
                                            a(str("open-timeout"), arg),
                                            a(str("close-timeout"), arg),
                                            a(str("inactivity-timeout"), arg),
                                            a(str("inactivity-tcp-timeout"), arg),
                                            a(str("inactivity-asymm-tcp-timeout"), arg),
                                            a(str("inactivity-non-tcp-timeout"), arg),
                                            a(str("session-timeout"), arg),
                                            str("disable-global-timeout-override"),
                                            a(str("tcp-tickles"), arg),
                                            b(str("trio-flow-offload"),
                                                c(
                                                    a(str("minimum-bytes"), arg)
                                                )
                                            ),
                                            a(str("fragment-limit"), arg),
                                            a(str("reassembly-timeout"), arg),
                                            str("cgn-pic"),
                                            a(str("pba-interim-logging-interval"), arg),
                                            b(str("session-limit"),
                                                c(
                                                    a(str("maximum"), arg),
                                                    a(str("rate"), arg),
                                                    a(str("cpu-load-threshold"), arg)
                                                )
                                            ),
                                            str("enable-subscriber-analysis"),
                                            str("disable-usp-tracing"),
                                            str("disable-drop-flows"),
                                            b(str("ignore-errors"),
                                                sc(
                                                    str("tcp"),
                                                    str("alg")
                                                )
                                            ).as(:oneline),
                                            b(str("capture"),
                                                c(
                                                    a(str("capture-size"), arg),
                                                    a(str("pkt-size"), arg),
                                                    a(str("logs-per-packet"), arg),
                                                    a(str("max-log-line-size"), arg),
                                                    b(str("filter"),
                                                        c(
                                                            b(str("source-ip"),
                                                                sc(
                                                                    b(str("wildcard"),
                                                                      ipaddr
                                                                    ),
                                                                      ipaddr
                                                                )
                                                            ).as(:oneline),
                                                            b(str("dest-ip"),
                                                                sc(
                                                                    b(str("wildcard"),
                                                                      ipaddr
                                                                    ),
                                                                      ipaddr
                                                                )
                                                            ).as(:oneline),
                                                            b(str("sw-sip"),
                                                                sc(
                                                                    b(str("wildcard"),
                                                                      ipv6addr
                                                                    ),
                                                                      ipv6addr
                                                                )
                                                            ).as(:oneline),
                                                            b(str("sw-dip"),
                                                                sc(
                                                                    b(str("wildcard"),
                                                                      ipaddr
                                                                    ),
                                                                      ipaddr
                                                                )
                                                            ).as(:oneline),
                                                            b(str("sport-range"),
                                                                sc(
                                                                    a(str("low"), arg),
                                                                    a(str("high"), arg)
                                                                )
                                                            ).as(:oneline),
                                                            b(str("dport-range"),
                                                                sc(
                                                                    a(str("low"), arg),
                                                                    a(str("high"), arg)
                                                                )
                                                            ).as(:oneline),
                                                            b(str("proto"),
                                                              (str("icmp") | str("tcp") | str("udp"))
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("t3-options"),
                                        c(
                                            b(str("loopback"),
                                              (str("local") | str("remote") | str("payload"))
                                            ),
                                            str("long-buildout"),
                                            str("no-long-buildout"),
                                            str("loop-timing"),
                                            str("no-loop-timing"),
                                            str("unframed"),
                                            str("no-unframed"),
                                            b(str("compatibility-mode"),
                                                sc(
                                                    c(
                                                      b(str("larscom"),
                                                          sc(
                                                              a(str("subrate"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("verilink"),
                                                          sc(
                                                              a(str("subrate"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("adtran"),
                                                          sc(
                                                              a(str("subrate"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("kentrox"),
                                                          sc(
                                                              a(str("subrate"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("digital-link"),
                                                          sc(
                                                              b(str("subrate"),
                                                                (str("301Kb") | str("601Kb") | str("902Kb") | str("1.2Mb") | str("1.5Mb") | str("1.8Mb") | str("2.1Mb") | str("2.4Mb") | str("2.7Mb") | str("3.0Mb") | str("3.3Mb") | str("3.6Mb") | str("3.9Mb") | str("4.2Mb") | str("4.5Mb") | str("4.8Mb") | str("5.1Mb") | str("5.4Mb") | str("5.7Mb") | str("6.0Mb") | str("6.3Mb") | str("6.6Mb") | str("6.9Mb") | str("7.2Mb") | str("7.5Mb") | str("7.8Mb") | str("8.1Mb") | str("8.4Mb") | str("8.7Mb") | str("9.0Mb") | str("9.3Mb") | str("9.6Mb") | str("9.9Mb") | str("10.2Mb") | str("10.5Mb") | str("10.8Mb") | str("11.1Mb") | str("11.4Mb") | str("11.7Mb") | str("12.0Mb") | str("12.3Mb") | str("12.6Mb") | str("12.9Mb") | str("13.2Mb") | str("13.5Mb") | str("13.8Mb") | str("14.1Mb") | str("14.4Mb") | str("14.7Mb") | str("15.0Mb") | str("15.3Mb") | str("15.6Mb") | str("15.9Mb") | str("16.2Mb") | str("16.5Mb") | str("16.8Mb") | str("17.1Mb") | str("17.4Mb") | str("17.7Mb") | str("18.0Mb") | str("18.3Mb") | str("18.6Mb") | str("18.9Mb") | str("19.2Mb") | str("19.5Mb") | str("19.8Mb") | str("20.1Mb") | str("20.5Mb") | str("20.8Mb") | str("21.1Mb") | str("21.4Mb") | str("21.7Mb") | str("22.0Mb") | str("22.3Mb") | str("22.6Mb") | str("22.9Mb") | str("23.2Mb") | str("23.5Mb") | str("23.8Mb") | str("24.1Mb") | str("24.4Mb") | str("24.7Mb") | str("25.0Mb") | str("25.3Mb") | str("25.6Mb") | str("25.9Mb") | str("26.2Mb") | str("26.5Mb") | str("26.8Mb") | str("27.1Mb") | str("27.4Mb") | str("27.7Mb") | str("28.0Mb") | str("28.3Mb") | str("28.6Mb") | str("28.9Mb") | str("29.2Mb") | str("29.5Mb") | str("29.8Mb") | str("30.1Mb") | str("30.4Mb") | str("30.7Mb") | str("31.0Mb") | str("31.3Mb") | str("31.6Mb") | str("31.9Mb") | str("32.2Mb") | str("32.5Mb") | str("32.8Mb") | str("33.1Mb") | str("33.4Mb") | str("33.7Mb") | str("34.0Mb") | str("34.3Mb") | str("34.6Mb") | str("34.9Mb") | str("35.2Mb") | str("35.5Mb") | str("35.8Mb") | str("36.1Mb") | str("36.4Mb") | str("36.7Mb") | str("37.0Mb") | str("37.3Mb") | str("37.6Mb") | str("37.9Mb") | str("38.2Mb") | str("38.5Mb") | str("38.8Mb") | str("39.1Mb") | str("39.4Mb") | str("39.7Mb") | str("40.0Mb") | str("40.3Mb") | str("40.6Mb") | str("40.9Mb") | str("41.2Mb") | str("41.5Mb") | str("41.8Mb") | str("42.1Mb") | str("42.4Mb") | str("42.7Mb") | str("43.0Mb") | str("43.3Mb") | str("43.6Mb") | str("43.9Mb") | str("44.2Mb"))
                                                              )
                                                          )
                                                      ).as(:oneline)
                                                    )
                                                )
                                            ).as(:oneline),
                                            str("payload-scrambler"),
                                            str("no-payload-scrambler"),
                                            str("cbit-parity"),
                                            str("no-cbit-parity"),
                                            b(str("fcs"),
                                              (str("32") | str("16"))
                                            ),
                                            b(str("idle-cycle-flag"),
                                              (str("flags") | str("ones"))
                                            ),
                                            b(str("start-end-flag"),
                                              (str("shared") | str("filler"))
                                            ),
                                            str("feac-loop-respond"),
                                            str("no-feac-loop-respond"),
                                            b(str("bert-algorithm"),
                                              (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                            ),
                                            a(str("bert-error-rate"), arg),
                                            a(str("bert-period"), arg),
                                            a(str("buildout"), arg),
                                            b(str("atm-encapsulation"),
                                              (str("plcp") | str("direct"))
                                            )
                                        )
                                    ),
                                    b(str("e3-options"),
                                        c(
                                            b(str("loopback"),
                                              (str("local") | str("remote"))
                                            ),
                                            str("unframed"),
                                            str("no-unframed"),
                                            b(str("compatibility-mode"),
                                                sc(
                                                    c(
                                                      str("larscom"),
                                                      b(str("digital-link"),
                                                          sc(
                                                              b(str("subrate"),
                                                                (str("358Kb") | str("716Kb") | str("1.1Mb") | str("1.4Mb") | str("1.8Mb") | str("2.1Mb") | str("2.5Mb") | str("2.9Mb") | str("3.2Mb") | str("3.6Mb") | str("3.9Mb") | str("4.3Mb") | str("4.7Mb") | str("5.0Mb") | str("5.4Mb") | str("5.7Mb") | str("6.1Mb") | str("6.4Mb") | str("6.8Mb") | str("7.2Mb") | str("7.5Mb") | str("7.9Mb") | str("8.2Mb") | str("8.6Mb") | str("9.0Mb") | str("9.3Mb") | str("9.7Mb") | str("10.0Mb") | str("10.4Mb") | str("10.7Mb") | str("11.1Mb") | str("11.5Mb") | str("11.8Mb") | str("12.2Mb") | str("12.5Mb") | str("12.9Mb") | str("13.2Mb") | str("13.6Mb") | str("14.0Mb") | str("14.3Mb") | str("14.7Mb") | str("15.0Mb") | str("15.4Mb") | str("15.8Mb") | str("16.1Mb") | str("16.5Mb") | str("16.8Mb") | str("17.2Mb") | str("17.5Mb") | str("17.9Mb") | str("18.3Mb") | str("18.6Mb") | str("19.0Mb") | str("19.3Mb") | str("19.7Mb") | str("20.0Mb") | str("20.4Mb") | str("20.8Mb") | str("21.1Mb") | str("21.5Mb") | str("21.8Mb") | str("22.2Mb") | str("22.6Mb") | str("22.9Mb") | str("23.3Mb") | str("23.6Mb") | str("24.0Mb") | str("24.3Mb") | str("24.7Mb") | str("25.1Mb") | str("25.4Mb") | str("25.8Mb") | str("26.1Mb") | str("26.5Mb") | str("26.9Mb") | str("27.2Mb") | str("27.6Mb") | str("27.9Mb") | str("28.3Mb") | str("28.6Mb") | str("29.0Mb") | str("29.4Mb") | str("29.7Mb") | str("30.1Mb") | str("30.4Mb") | str("30.8Mb") | str("31.1Mb") | str("31.5Mb") | str("31.9Mb") | str("32.2Mb") | str("32.6Mb") | str("32.9Mb") | str("33.3Mb") | str("33.7Mb") | str("34.0Mb"))
                                                              )
                                                          )
                                                      ).as(:oneline),
                                                      b(str("kentrox"),
                                                          sc(
                                                              a(str("subrate"), arg)
                                                          )
                                                      ).as(:oneline)
                                                    )
                                                )
                                            ).as(:oneline),
                                            str("payload-scrambler"),
                                            str("no-payload-scrambler"),
                                            b(str("fcs"),
                                              (str("32") | str("16"))
                                            ),
                                            b(str("idle-cycle-flag"),
                                              (str("flags") | str("ones"))
                                            ),
                                            str("invert-data"),
                                            b(str("start-end-flag"),
                                              (str("shared") | str("filler"))
                                            ),
                                            b(str("bert-algorithm"),
                                              (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                            ),
                                            a(str("bert-error-rate"), arg),
                                            a(str("bert-period"), arg),
                                            a(str("buildout"), arg),
                                            b(str("atm-encapsulation"),
                                              (str("plcp") | str("direct"))
                                            ),
                                            b(str("framing"),
                                              (str("g.751") | str("g.832"))
                                            )
                                        )
                                    ),
                                    b(str("e1-options"),
                                        c(
                                            a(str("timeslots"), arg),
                                            b(str("loopback"),
                                              (str("local") | str("remote"))
                                            ),
                                            b(str("framing"),
                                              (str("g704") | str("unframed") | str("g704-no-crc4"))
                                            ),
                                            b(str("fcs"),
                                              (str("32") | str("16"))
                                            ),
                                            str("invert-data"),
                                            b(str("idle-cycle-flag"),
                                              (str("flags") | str("ones"))
                                            ),
                                            b(str("start-end-flag"),
                                              (str("shared") | str("filler"))
                                            ),
                                            b(str("bert-algorithm"),
                                              (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                            ),
                                            a(str("bert-error-rate"), arg),
                                            a(str("bert-period"), arg)
                                        )
                                    ),
                                    b(str("t1-options"),
                                        c(
                                            a(str("timeslots"), arg),
                                            a(str("voice-timeslots"), arg),
                                            b(str("disable-remote-alarm-detection"),
                                              (str("yellow"))
                                            ),
                                            b(str("loopback"),
                                              (str("local") | str("remote") | str("payload"))
                                            ),
                                            b(str("buildout"),
                                              (str("0-132") | str("133-265") | str("266-398") | str("399-531") | str("532-655") | str("long-0db") | str("long-7.5db") | str("long-15db") | str("long-22.5db"))
                                            ),
                                            b(str("byte-encoding"),
                                              (str("nx64") | str("nx56"))
                                            ),
                                            b(str("line-encoding"),
                                              (str("ami") | str("b8zs"))
                                            ),
                                            str("invert-data"),
                                            b(str("framing"),
                                              (str("sf") | str("esf"))
                                            ),
                                            b(str("fcs"),
                                              (str("32") | str("16"))
                                            ),
                                            b(str("idle-cycle-flag"),
                                              (str("flags") | str("ones"))
                                            ),
                                            b(str("start-end-flag"),
                                              (str("shared") | str("filler"))
                                            ),
                                            b(str("bert-algorithm"),
                                              (str("pseudo-2e3") | str("pseudo-2e4") | str("pseudo-2e5") | str("pseudo-2e6") | str("pseudo-2e7") | str("pseudo-2e9-o153") | str("pseudo-2e10") | str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e17") | str("pseudo-2e18") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("pseudo-2e21") | str("pseudo-2e22") | str("pseudo-2e23-o151") | str("pseudo-2e25") | str("pseudo-2e28") | str("pseudo-2e29") | str("pseudo-2e31") | str("pseudo-2e32") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4"))
                                            ),
                                            a(str("bert-error-rate"), arg),
                                            a(str("bert-period"), arg),
                                            str("remote-loopback-respond"),
                                            b(str("crc-major-alarm-threshold"),
                                              (str("1e-3") | str("5e-4") | str("1e-4") | str("5e-5") | str("1e-5"))
                                            ),
                                            b(str("crc-minor-alarm-threshold"),
                                              (str("1e-3") | str("5e-4") | str("1e-4") | str("5e-5") | str("1e-5") | str("5e-6") | str("1e-6"))
                                            ),
                                            b(str("alarm-compliance"),
                                              (str("accunet-t1-5-service"))
                                            )
                                        )
                                    ),
                                    b(str("ds0-options"),
                                        c(
                                            b(str("loopback"),
                                              (str("payload"))
                                            ),
                                            b(str("byte-encoding"),
                                              (str("nx64") | str("nx56"))
                                            ),
                                            str("invert-data"),
                                            b(str("fcs"),
                                              (str("32") | str("16"))
                                            ),
                                            b(str("idle-cycle-flag"),
                                              (str("flags") | str("ones"))
                                            ),
                                            b(str("start-end-flag"),
                                              (str("shared") | str("filler"))
                                            ),
                                            b(str("bert-algorithm"),
                                              (str("pseudo-2e11-o152") | str("pseudo-2e15-o151") | str("pseudo-2e20-o153") | str("pseudo-2e20-o151") | str("all-ones-repeating") | str("all-zeros-repeating") | str("alternating-ones-zeros") | str("alternating-double-ones-zeros") | str("repeating-3-in-24") | str("repeating-1-in-8") | str("repeating-1-in-4") | str("repeating-1-in-16"))
                                            ),
                                            a(str("bert-error-rate"), arg),
                                            a(str("bert-period"), arg)
                                        )
                                    ),
                                    b(str("serial-options"),
                                        c(
                                            b(str("line-protocol"),
                                              (str("eia530") | str("v.35") | str("x.21"))
                                            ),
                                            c(
                                              b(str("dte-options"),
                                                  c(
                                                      str("ignore-all"),
                                                      b(str("dtr"),
                                                          sc(
                                                              c(
                                                                str("assert"),
                                                                str("de-assert"),
                                                                str("normal"),
                                                                b(str("auto-synchronize"),
                                                                    c(
                                                                        a(str("duration"), arg),
                                                                        a(str("interval"), arg)
                                                                    )
                                                                )
                                                              )
                                                          )
                                                      ).as(:oneline),
                                                      b(str("control-signal"),
                                                        (str("assert") | str("de-assert") | str("normal"))
                                                      ),
                                                      b(str("rts"),
                                                        (str("assert") | str("de-assert") | str("normal"))
                                                      ),
                                                      b(str("dcd"),
                                                        (str("require") | str("ignore") | str("normal"))
                                                      ),
                                                      b(str("dsr"),
                                                        (str("require") | str("ignore") | str("normal"))
                                                      ),
                                                      b(str("cts"),
                                                        (str("require") | str("ignore") | str("normal"))
                                                      ),
                                                      b(str("indication"),
                                                        (str("require") | str("ignore") | str("normal"))
                                                      ),
                                                      b(str("tm"),
                                                        (str("require") | str("ignore") | str("normal"))
                                                      )
                                                  )
                                              ),
                                              b(str("dce-options"),
                                                  c(
                                                      str("ignore-all"),
                                                      b(str("dtr"),
                                                        (str("require") | str("ignore") | str("normal"))
                                                      ),
                                                      b(str("rts"),
                                                        (str("require") | str("ignore") | str("normal"))
                                                      ),
                                                      b(str("dcd"),
                                                        (str("assert") | str("de-assert") | str("normal"))
                                                      ),
                                                      b(str("dsr"),
                                                        (str("assert") | str("de-assert") | str("normal"))
                                                      ),
                                                      b(str("cts"),
                                                        (str("assert") | str("de-assert") | str("normal"))
                                                      ),
                                                      b(str("tm"),
                                                        (str("require") | str("ignore") | str("normal"))
                                                      ),
                                                      str("dce-loopback-override")
                                                  )
                                              )
                                            ),
                                            b(str("dtr-circuit"),
                                              (str("balanced") | str("unbalanced"))
                                            ),
                                            b(str("dtr-polarity"),
                                              (str("positive") | str("negative"))
                                            ),
                                            b(str("rts-polarity"),
                                              (str("positive") | str("negative"))
                                            ),
                                            b(str("control-polarity"),
                                              (str("positive") | str("negative"))
                                            ),
                                            b(str("dcd-polarity"),
                                              (str("positive") | str("negative"))
                                            ),
                                            b(str("dsr-polarity"),
                                              (str("positive") | str("negative"))
                                            ),
                                            b(str("cts-polarity"),
                                              (str("positive") | str("negative"))
                                            ),
                                            b(str("indication-polarity"),
                                              (str("positive") | str("negative"))
                                            ),
                                            b(str("tm-polarity"),
                                              (str("positive") | str("negative"))
                                            ),
                                            b(str("clocking-mode"),
                                              (str("dce") | str("internal") | str("loop"))
                                            ),
                                            b(str("transmit-clock"),
                                              (str("invert"))
                                            ),
                                            b(str("clock-rate"),
                                              (str("2.048mhz") | str("2.341mhz") | str("2.731mhz") | str("3.277mhz") | str("4.096mhz") | str("5.461mhz") | str("8.192mhz") | str("16.384mhz") | str("1.2khz") | str("2.4khz") | str("9.6khz") | str("19.2khz") | str("38.4khz") | str("56.0khz") | str("64.0khz") | str("72.0khz") | str("125.0khz") | str("148.0khz") | str("250.0khz") | str("500.0khz") | str("800.0khz") | str("1.0mhz") | str("1.3mhz") | str("2.0mhz") | str("4.0mhz") | str("8.0mhz"))
                                            ),
                                            b(str("loopback"),
                                              (str("local") | str("remote") | str("dce-local") | str("dce-remote"))
                                            ),
                                            b(str("encoding"),
                                              (str("nrz") | str("nrzi"))
                                            ),
                                            b(str("idle-cycle-flag"),
                                              (str("flags") | str("ones"))
                                            )
                                        )
                                    ),
                                    str("gratuitous-arp-reply"),
                                    str("no-gratuitous-arp-reply"),
                                    str("no-gratuitous-arp-request"),
                                    str("no-no-gratuitous-arp-request"),
                                    str("arp-l2-validate"),
                                    b(str("ether-options"),
                                        c(
                                            str("loopback"),
                                            str("no-loopback"),
                                            str("source-filtering"),
                                            str("no-source-filtering"),
                                            b(str("ethernet-switch-profile"),
                                                c(
                                                    a(str("tag-protocol-id"), arg),
                                                    b(str("ethernet-policer-profile"),
                                                        c(
                                                            b(str("input-priority-map"),
                                                              cos_policer_input_priority_map
                                                            ),
                                                            b(str("output-priority-map"),
                                                              cos_policer_output_priority_map
                                                            ),
                                                            b(str("policer"),
                                                              cos_policer
                                                            )
                                                        )
                                                    ),
                                                    b(str("storm-control"),
                                                        c(
                                                            arg
                                                        )
                                                    ),
                                                    b(str("recovery-timeout"),
                                                        sc(
                                                              arg
                                                        )
                                                    ).as(:oneline),
                                                    str("mac-learn-enable"),
                                                    str("no-mac-learn-enable")
                                                )
                                            ),
                                            str("asynchronous-notification"),
                                            a(str("source-address-filter"), arg).as(:oneline),
                                            str("auto-negotiation"),
                                            str("no-auto-negotiation"),
                                            str("flow-control"),
                                            str("no-flow-control"),
                                            b(str("configured-flow-control"),
                                                c(
                                                    b(str("rx-buffers"),
                                                      (str("on") | str("off"))
                                                    ),
                                                    b(str("tx-buffers"),
                                                      (str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("link-mode"),
                                              (str("automatic") | str("half-duplex") | str("full-duplex"))
                                            ),
                                            b(str("mpls"),
                                              mpls_ifd_options
                                            ),
                                            str("ignore-l3-incompletes"),
                                            str("no-auto-mdix"),
                                            b(str("speed"),
                                                c(
                                                    c(
                                                      b(str("auto-negotiation"),
                                                          sc(
                                                              str("auto-negotiate-10-100")
                                                          )
                                                      ).as(:oneline),
                                                      str("ethernet-10m"),
                                                      str("ethernet-100m"),
                                                      str("ethernet-1g"),
                                                      str("ethernet-10g")
                                                    )
                                                )
                                            ),
                                            b(str("802.3ad"),
                                                c(
                                                    b(str("lacp"),
                                                        c(
                                                            str("force-up"),
                                                            a(str("port-priority"), arg)
                                                        )
                                                    ),
                                                      interface_device,
                                                    c(
                                                      str("primary"),
                                                      str("backup")
                                                    ),
                                                    b(str("link-protection-sub-group"),
                                                        c(
                                                              arg
                                                        )
                                                    ),
                                                    a(str("port-priority"), arg)
                                                )
                                            ),
                                            str("ieee-802-3az-eee"),
                                            b(str("mdi-mode"),
                                              (str("auto") | str("force") | str("mdi") | str("mdix"))
                                            ),
                                            b(str("redundant-parent"),
                                                c(
                                                      interface_device
                                                )
                                            ),
                                            str("autostate-exclude")
                                        )
                                    ),
                                    b(str("fibrechannel-options"),
                                        c(
                                            str("loopback"),
                                            str("no-loopback"),
                                            a(str("bb-sc-n"), arg),
                                            b(str("speed"),
                                              (str("auto-negotiation") | str("1g") | str("2g") | str("4g") | str("8g"))
                                            )
                                        )
                                    ),
                                    b(str("gigether-options"),
                                        c(
                                            str("loopback"),
                                            str("no-loopback"),
                                            str("loopback-remote"),
                                            str("flow-control"),
                                            str("no-flow-control"),
                                            str("source-filtering"),
                                            str("no-source-filtering"),
                                            c(
                                              str("no-auto-negotiation"),
                                              b(str("auto-negotiation"),
                                                  sc(
                                                      b(str("remote-fault"),
                                                        (str("local-interface-offline") | str("local-interface-online"))
                                                      )
                                                  )
                                              ).as(:oneline)
                                            ),
                                            b(str("mac-mode"),
                                              (str("sgmii") | str("mac-mode-1000base-x"))
                                            ),
                                            str("asynchronous-notification"),
                                            a(str("source-address-filter"), arg).as(:oneline),
                                            str("pad-to-minimum-frame-size"),
                                            b(str("redundant-parent"),
                                                c(
                                                      interface_device
                                                )
                                            ),
                                            b(str("802.3ad"),
                                                c(
                                                    b(str("lacp"),
                                                        c(
                                                            a(str("port-priority"), arg)
                                                        )
                                                    ),
                                                      interface_device,
                                                    a(str("link-index"), arg),
                                                    c(
                                                      str("primary"),
                                                      str("backup")
                                                    ),
                                                    a(str("distribution-list"), arg)
                                                )
                                            ),
                                            b(str("ethernet-switch-profile"),
                                                c(
                                                    a(str("tag-protocol-id"), arg),
                                                    b(str("ethernet-policer-profile"),
                                                        c(
                                                            b(str("ieee802.1-priority-map"),
                                                                c(
                                                                    a(str("premium"), arg)
                                                                )
                                                            ),
                                                            b(str("input-priority-map"),
                                                              cos_policer_input_priority_map
                                                            ),
                                                            b(str("output-priority-map"),
                                                              cos_policer_output_priority_map
                                                            ),
                                                            b(str("policer"),
                                                              cos_policer
                                                            )
                                                        )
                                                    ),
                                                    b(str("accept-from"),
                                                        c(
                                                            b(str("mac-address"),
                                                              mac_list
                                                            )
                                                        )
                                                    ),
                                                    str("reject-the-rest"),
                                                    str("no-reject-the-rest"),
                                                    str("mac-learn-enable")
                                                )
                                            ),
                                            b(str("mpls"),
                                              mpls_ifd_options
                                            ),
                                            str("ignore-l3-incompletes"),
                                            str("no-auto-mdix"),
                                            str("ieee-802-3az-eee"),
                                            a(str("mru"), arg),
                                            b(str("fec"),
                                              (str("none") | str("fec91") | str("fec74") | str("fec108"))
                                            ),
                                            b(str("speed"),
                                              (str("1g") | str("10g"))
                                            )
                                        )
                                    ),
                                    b(str("optics-options"),
                                        c(
                                            b(str("wavelength"),
                                              (str("1568.77") | str("1568.36") | str("1568.31") | str("1568.26") | str("1568.21") | str("1568.16") | str("1568.11") | str("1568.05") | str("1568.00") | str("1567.95") | str("1567.90") | str("1567.85") | str("1567.80") | str("1567.75") | str("1567.70") | str("1567.64") | str("1567.59") | str("1567.54") | str("1567.49") | str("1567.44") | str("1567.39") | str("1567.34") | str("1567.29") | str("1567.23") | str("1567.18") | str("1567.13") | str("1567.08") | str("1567.03") | str("1566.98") | str("1566.93") | str("1566.88") | str("1566.83") | str("1566.77") | str("1566.72") | str("1566.67") | str("1566.62") | str("1566.57") | str("1566.52") | str("1566.47") | str("1566.42") | str("1566.36") | str("1566.31") | str("1566.26") | str("1566.21") | str("1566.16") | str("1566.11") | str("1566.06") | str("1566.01") | str("1565.96") | str("1565.90") | str("1565.85") | str("1565.80") | str("1565.75") | str("1565.70") | str("1565.65") | str("1565.60") | str("1565.55") | str("1565.50") | str("1565.44") | str("1565.39") | str("1565.34") | str("1565.29") | str("1565.24") | str("1565.19") | str("1565.14") | str("1565.09") | str("1565.04") | str("1564.99") | str("1564.93") | str("1564.88") | str("1564.83") | str("1564.78") | str("1564.73") | str("1564.68") | str("1564.63") | str("1564.58") | str("1564.53") | str("1564.47") | str("1564.42") | str("1564.37") | str("1564.32") | str("1564.27") | str("1564.22") | str("1564.17") | str("1564.12") | str("1564.07") | str("1564.02") | str("1563.96") | str("1563.91") | str("1563.86") | str("1563.81") | str("1563.76") | str("1563.71") | str("1563.66") | str("1563.61") | str("1563.56") | str("1563.51") | str("1563.45") | str("1563.40") | str("1563.35") | str("1563.30") | str("1563.25") | str("1563.20") | str("1563.15") | str("1563.10") | str("1563.05") | str("1563.00") | str("1562.95") | str("1562.89") | str("1562.84") | str("1562.79") | str("1562.74") | str("1562.69") | str("1562.64") | str("1562.59") | str("1562.54") | str("1562.49") | str("1562.44") | str("1562.39") | str("1562.33") | str("1562.28") | str("1562.23") | str("1562.18") | str("1562.13") | str("1562.08") | str("1562.03") | str("1561.98") | str("1561.93") | str("1561.88") | str("1561.83") | str("1561.77") | str("1561.72") | str("1561.67") | str("1561.62") | str("1561.57") | str("1561.52") | str("1561.47") | str("1561.42") | str("1561.37") | str("1561.32") | str("1561.27") | str("1561.22") | str("1561.16") | str("1561.11") | str("1561.06") | str("1561.01") | str("1560.96") | str("1560.91") | str("1560.86") | str("1560.81") | str("1560.76") | str("1560.71") | str("1560.66") | str("1560.61") | str("1560.56") | str("1560.50") | str("1560.45") | str("1560.40") | str("1560.35") | str("1560.30") | str("1560.25") | str("1560.20") | str("1560.15") | str("1560.10") | str("1560.05") | str("1560.00") | str("1559.95") | str("1559.90") | str("1559.84") | str("1559.79") | str("1559.74") | str("1559.69") | str("1559.64") | str("1559.59") | str("1559.54") | str("1559.49") | str("1559.44") | str("1559.39") | str("1559.34") | str("1559.29") | str("1559.24") | str("1559.19") | str("1559.14") | str("1559.08") | str("1559.03") | str("1558.98") | str("1558.93") | str("1558.88") | str("1558.83") | str("1558.78") | str("1558.73") | str("1558.68") | str("1558.63") | str("1558.58") | str("1558.53") | str("1558.48") | str("1558.43") | str("1558.38") | str("1558.32") | str("1558.27") | str("1558.22") | str("1558.17") | str("1558.12") | str("1558.07") | str("1558.02") | str("1557.97") | str("1557.92") | str("1557.87") | str("1557.82") | str("1557.77") | str("1557.72") | str("1557.67") | str("1557.62") | str("1557.57") | str("1557.52") | str("1557.46") | str("1557.41") | str("1557.36") | str("1557.31") | str("1557.26") | str("1557.21") | str("1557.16") | str("1557.11") | str("1557.06") | str("1557.01") | str("1556.96") | str("1556.91") | str("1556.86") | str("1556.81") | str("1556.76") | str("1556.71") | str("1556.66") | str("1556.61") | str("1556.55") | str("1556.50") | str("1556.45") | str("1556.40") | str("1556.35") | str("1556.30") | str("1556.25") | str("1556.20") | str("1556.15") | str("1556.10") | str("1556.05") | str("1556.00") | str("1555.95") | str("1555.90") | str("1555.85") | str("1555.80") | str("1555.75") | str("1555.70") | str("1555.65") | str("1555.60") | str("1555.55") | str("1555.49") | str("1555.44") | str("1555.39") | str("1555.34") | str("1555.29") | str("1555.24") | str("1555.19") | str("1555.14") | str("1555.09") | str("1555.04") | str("1554.99") | str("1554.94") | str("1554.89") | str("1554.84") | str("1554.79") | str("1554.74") | str("1554.69") | str("1554.64") | str("1554.59") | str("1554.54") | str("1554.49") | str("1554.44") | str("1554.39") | str("1554.34") | str("1554.29") | str("1554.23") | str("1554.18") | str("1554.13") | str("1554.08") | str("1554.03") | str("1553.98") | str("1553.93") | str("1553.88") | str("1553.83") | str("1553.78") | str("1553.73") | str("1553.68") | str("1553.63") | str("1553.58") | str("1553.53") | str("1553.48") | str("1553.43") | str("1553.38") | str("1553.33") | str("1553.28") | str("1553.23") | str("1553.18") | str("1553.13") | str("1553.08") | str("1553.03") | str("1552.98") | str("1552.93") | str("1552.88") | str("1552.83") | str("1552.78") | str("1552.73") | str("1552.68") | str("1552.62") | str("1552.57") | str("1552.52") | str("1552.47") | str("1552.42") | str("1552.37") | str("1552.32") | str("1552.27") | str("1552.22") | str("1552.17") | str("1552.12") | str("1552.07") | str("1552.02") | str("1551.97") | str("1551.92") | str("1551.87") | str("1551.82") | str("1551.77") | str("1551.72") | str("1551.67") | str("1551.62") | str("1551.57") | str("1551.52") | str("1551.47") | str("1551.42") | str("1551.37") | str("1551.32") | str("1551.27") | str("1551.22") | str("1551.17") | str("1551.12") | str("1551.07") | str("1551.02") | str("1550.97") | str("1550.92") | str("1550.87") | str("1550.82") | str("1550.77") | str("1550.72") | str("1550.67") | str("1550.62") | str("1550.57") | str("1550.52") | str("1550.47") | str("1550.42") | str("1550.37") | str("1550.32") | str("1550.27") | str("1550.22") | str("1550.17") | str("1550.12") | str("1550.07") | str("1550.02") | str("1549.97") | str("1549.92") | str("1549.87") | str("1549.82") | str("1549.77") | str("1549.72") | str("1549.67") | str("1549.62") | str("1549.57") | str("1549.52") | str("1549.47") | str("1549.42") | str("1549.37") | str("1549.32") | str("1549.26") | str("1549.21") | str("1549.16") | str("1549.11") | str("1549.06") | str("1549.01") | str("1548.96") | str("1548.91") | str("1548.86") | str("1548.81") | str("1548.76") | str("1548.71") | str("1548.66") | str("1548.61") | str("1548.56") | str("1548.51") | str("1548.46") | str("1548.41") | str("1548.36") | str("1548.31") | str("1548.26") | str("1548.21") | str("1548.16") | str("1548.11") | str("1548.06") | str("1548.02") | str("1547.97") | str("1547.92") | str("1547.87") | str("1547.82") | str("1547.77") | str("1547.72") | str("1547.67") | str("1547.62") | str("1547.57") | str("1547.52") | str("1547.47") | str("1547.42") | str("1547.37") | str("1547.32") | str("1547.27") | str("1547.22") | str("1547.17") | str("1547.12") | str("1547.07") | str("1547.02") | str("1546.97") | str("1546.92") | str("1546.87") | str("1546.82") | str("1546.77") | str("1546.72") | str("1546.67") | str("1546.62") | str("1546.57") | str("1546.52") | str("1546.47") | str("1546.42") | str("1546.37") | str("1546.32") | str("1546.27") | str("1546.22") | str("1546.17") | str("1546.12") | str("1546.07") | str("1546.02") | str("1545.97") | str("1545.92") | str("1545.87") | str("1545.82") | str("1545.77") | str("1545.72") | str("1545.67") | str("1545.62") | str("1545.57") | str("1545.52") | str("1545.47") | str("1545.42") | str("1545.37") | str("1545.32") | str("1545.27") | str("1545.22") | str("1545.17") | str("1545.12") | str("1545.07") | str("1545.02") | str("1544.97") | str("1544.92") | str("1544.87") | str("1544.82") | str("1544.77") | str("1544.72") | str("1544.68") | str("1544.63") | str("1544.58") | str("1544.53") | str("1544.48") | str("1544.43") | str("1544.38") | str("1544.33") | str("1544.28") | str("1544.23") | str("1544.18") | str("1544.13") | str("1544.08") | str("1544.03") | str("1543.98") | str("1543.93") | str("1543.88") | str("1543.83") | str("1543.78") | str("1543.73") | str("1543.68") | str("1543.63") | str("1543.58") | str("1543.53") | str("1543.48") | str("1543.43") | str("1543.38") | str("1543.33") | str("1543.28") | str("1543.23") | str("1543.18") | str("1543.13") | str("1543.08") | str("1543.04") | str("1542.99") | str("1542.94") | str("1542.89") | str("1542.84") | str("1542.79") | str("1542.74") | str("1542.69") | str("1542.64") | str("1542.59") | str("1542.54") | str("1542.49") | str("1542.44") | str("1542.39") | str("1542.34") | str("1542.29") | str("1542.24") | str("1542.19") | str("1542.14") | str("1542.09") | str("1542.04") | str("1541.99") | str("1541.94") | str("1541.89") | str("1541.84") | str("1541.80") | str("1541.75") | str("1541.70") | str("1541.65") | str("1541.60") | str("1541.55") | str("1541.50") | str("1541.45") | str("1541.40") | str("1541.35") | str("1541.30") | str("1541.25") | str("1541.20") | str("1541.15") | str("1541.10") | str("1541.05") | str("1541.00") | str("1540.95") | str("1540.90") | str("1540.85") | str("1540.80") | str("1540.76") | str("1540.71") | str("1540.66") | str("1540.61") | str("1540.56") | str("1540.51") | str("1540.46") | str("1540.41") | str("1540.36") | str("1540.31") | str("1540.26") | str("1540.21") | str("1540.16") | str("1540.11") | str("1540.06") | str("1540.01") | str("1539.96") | str("1539.91") | str("1539.86") | str("1539.82") | str("1539.77") | str("1539.72") | str("1539.67") | str("1539.62") | str("1539.57") | str("1539.52") | str("1539.47") | str("1539.42") | str("1539.37") | str("1539.32") | str("1539.27") | str("1539.22") | str("1539.17") | str("1539.12") | str("1539.07") | str("1539.03") | str("1538.98") | str("1538.93") | str("1538.88") | str("1538.83") | str("1538.78") | str("1538.73") | str("1538.68") | str("1538.63") | str("1538.58") | str("1538.53") | str("1538.48") | str("1538.43") | str("1538.38") | str("1538.33") | str("1538.28") | str("1538.24") | str("1538.19") | str("1538.14") | str("1538.09") | str("1538.04") | str("1537.99") | str("1537.94") | str("1537.89") | str("1537.84") | str("1537.79") | str("1537.74") | str("1537.69") | str("1537.64") | str("1537.59") | str("1537.55") | str("1537.50") | str("1537.45") | str("1537.40") | str("1537.35") | str("1537.30") | str("1537.25") | str("1537.20") | str("1537.15") | str("1537.10") | str("1537.05") | str("1537.00") | str("1536.95") | str("1536.90") | str("1536.86") | str("1536.81") | str("1536.76") | str("1536.71") | str("1536.66") | str("1536.61") | str("1536.56") | str("1536.51") | str("1536.46") | str("1536.41") | str("1536.36") | str("1536.31") | str("1536.26") | str("1536.22") | str("1536.17") | str("1536.12") | str("1536.07") | str("1536.02") | str("1535.97") | str("1535.92") | str("1535.87") | str("1535.82") | str("1535.77") | str("1535.72") | str("1535.67") | str("1535.63") | str("1535.58") | str("1535.53") | str("1535.48") | str("1535.43") | str("1535.38") | str("1535.33") | str("1535.28") | str("1535.23") | str("1535.18") | str("1535.13") | str("1535.08") | str("1535.04") | str("1534.99") | str("1534.94") | str("1534.89") | str("1534.84") | str("1534.79") | str("1534.74") | str("1534.69") | str("1534.64") | str("1534.59") | str("1534.54") | str("1534.50") | str("1534.45") | str("1534.40") | str("1534.35") | str("1534.30") | str("1534.25") | str("1534.20") | str("1534.15") | str("1534.10") | str("1534.05") | str("1534.00") | str("1533.96") | str("1533.91") | str("1533.86") | str("1533.81") | str("1533.76") | str("1533.71") | str("1533.66") | str("1533.61") | str("1533.56") | str("1533.51") | str("1533.47") | str("1533.42") | str("1533.37") | str("1533.32") | str("1533.27") | str("1533.22") | str("1533.17") | str("1533.12") | str("1533.07") | str("1533.02") | str("1532.98") | str("1532.93") | str("1532.88") | str("1532.83") | str("1532.78") | str("1532.73") | str("1532.68") | str("1532.63") | str("1532.58") | str("1532.53") | str("1532.49") | str("1532.44") | str("1532.39") | str("1532.34") | str("1532.29") | str("1532.24") | str("1532.19") | str("1532.14") | str("1532.09") | str("1532.04") | str("1532.00") | str("1531.95") | str("1531.90") | str("1531.85") | str("1531.80") | str("1531.75") | str("1531.70") | str("1531.65") | str("1531.60") | str("1531.56") | str("1531.51") | str("1531.46") | str("1531.41") | str("1531.36") | str("1531.31") | str("1531.26") | str("1531.21") | str("1531.16") | str("1531.12") | str("1531.07") | str("1531.02") | str("1530.97") | str("1530.92") | str("1530.87") | str("1530.82") | str("1530.77") | str("1530.72") | str("1530.68") | str("1530.63") | str("1530.58") | str("1530.53") | str("1530.48") | str("1530.43") | str("1530.38") | str("1530.33") | str("1530.29") | str("1530.24") | str("1530.19") | str("1530.14") | str("1530.09") | str("1530.04") | str("1529.99") | str("1529.94") | str("1529.89") | str("1529.85") | str("1529.80") | str("1529.75") | str("1529.70") | str("1529.65") | str("1529.60") | str("1529.55") | str("1529.50") | str("1529.46") | str("1529.41") | str("1529.36") | str("1529.31") | str("1529.26") | str("1529.21") | str("1529.16") | str("1529.11") | str("1529.07") | str("1529.02") | str("1528.97") | str("1528.92") | str("1528.87") | str("1528.82") | str("1528.77") | str("1528.38"))
                                            ),
                                            a(str("tx-power"), arg),
                                            str("loopback"),
                                            a(str("los-warning-threshold"), arg),
                                            a(str("los-alarm-threshold"), arg),
                                            b(str("modulation-format"),
                                              (str("16qam") | str("8qam") | str("qpsk"))
                                            ),
                                            str("laser-enable"),
                                            str("no-laser-enable"),
                                            str("is-ma"),
                                            str("no-is-ma"),
                                            b(str("encoding"),
                                              (str("differential") | str("non-differential"))
                                            ),
                                            b(str("fec"),
                                              (str("sdfec") | str("sdfec25") | str("hgfec") | str("sdfec15"))
                                            ),
                                            str("high-polarization"),
                                            b(str("signal-degrade"),
                                                c(
                                                    a(str("interval"), arg),
                                                    a(str("ber-threshold-clear"), arg),
                                                    a(str("ber-threshold-signal-degrade"), arg),
                                                    a(str("q-threshold-signal-degrade-clear"), arg),
                                                    a(str("q-threshold-signal-degrade"), arg)
                                                )
                                            ),
                                            a(str("alarm"), enum(str("low-light-alarm")),
                                                c(
                                                    c(
                                                      str("syslog"),
                                                      str("link-down")
                                                    )
                                                )
                                            ),
                                            b(str("tca"),
                                                c(
                                                    b(str("tx-power-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tx-power-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("rx-power-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("rx-power-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("temperature-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("temperature-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("carrier-frequency-offset-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("carrier-frequency-offset-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("fec-ber"),
                                                        sc(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    b(str("tec-current-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("tec-current-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("residual-isi-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("residual-isi-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("pam-histogram-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("snr-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("fec-corrected-errors-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("fec-ucorrected-words-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("laser-frequency-error-high-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    ),
                                                    b(str("laser-frequency-error-low-tca"),
                                                        c(
                                                            str("enable-tca"),
                                                            str("no-enable-tca"),
                                                            a(str("threshold"), arg),
                                                            a(str("threshold-24hrs"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            a(str("warning"), enum(str("low-light-warning")),
                                                c(
                                                    c(
                                                      str("syslog"),
                                                      str("link-down")
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("otn-options"),
                                      otn_options_type
                                    ),
                                    b(str("och-options"),
                                      och_attributes
                                    ),
                                    b(str("otu-options"),
                                      otu_attributes
                                    ),
                                    b(str("odu-options"),
                                      odu_attributes
                                    ),
                                    b(str("ett-options"),
                                      ett_attributes
                                    ),
                                    b(str("fastether-options"),
                                        c(
                                            str("loopback"),
                                            str("no-loopback"),
                                            str("flow-control"),
                                            str("no-flow-control"),
                                            str("source-filtering"),
                                            str("no-source-filtering"),
                                            str("auto-negotiation"),
                                            str("no-auto-negotiation"),
                                            a(str("ingress-rate-limit"), arg),
                                            a(str("source-address-filter"), arg).as(:oneline),
                                            b(str("redundant-parent"),
                                                c(
                                                      interface_device
                                                )
                                            ),
                                            b(str("802.3ad"),
                                                c(
                                                    b(str("lacp"),
                                                        c(
                                                            a(str("port-priority"), arg)
                                                        )
                                                    ),
                                                      interface_device,
                                                    c(
                                                      str("primary"),
                                                      str("backup")
                                                    )
                                                )
                                            ),
                                            b(str("mpls"),
                                              mpls_ifd_options
                                            ),
                                            str("ignore-l3-incompletes")
                                        )
                                    ),
                                    b(str("redundant-ether-options"),
                                        c(
                                            a(str("redundancy-group"), arg),
                                            str("loopback"),
                                            str("no-loopback"),
                                            str("flow-control"),
                                            str("no-flow-control"),
                                            str("source-filtering"),
                                            str("no-source-filtering"),
                                            a(str("source-address-filter"), arg).as(:oneline),
                                            b(str("link-speed"),
                                              (str("10m") | str("100m") | str("1g") | str("10g"))
                                            ),
                                            a(str("minimum-links"), arg),
                                            b(str("lacp"),
                                                c(
                                                    c(
                                                      str("active"),
                                                      str("passive")
                                                    ),
                                                    b(str("periodic"),
                                                      (str("fast") | str("slow"))
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("aggregated-ether-options"),
                                        c(
                                            str("loopback"),
                                            str("no-loopback"),
                                            str("flow-control"),
                                            str("no-flow-control"),
                                            str("source-filtering"),
                                            str("no-source-filtering"),
                                            str("autostate-exclude"),
                                            b(str("link-protection"),
                                                c(
                                                    str("revertive"),
                                                    str("non-revertive"),
                                                    b(str("backup-state"),
                                                      (str("accept-data") | str("discard-data") | str("down"))
                                                    ),
                                                    b(str("rtg-config"),
                                                        c(
                                                            a(str("preempt-cutover-timer"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            str("fcoe-lag"),
                                            str("no-fcoe-lag"),
                                            a(str("source-address-filter"), arg).as(:oneline),
                                            b(str("configured-flow-control"),
                                                c(
                                                    b(str("rx-buffers"),
                                                      (str("on") | str("off"))
                                                    ),
                                                    b(str("tx-buffers"),
                                                      (str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("load-balance"),
                                              aggregate_load_balance
                                            ),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    b(str("version"),
                                                      (str("0") | str("1") | str("automatic"))
                                                    ),
                                                    a(str("minimum-interval"), arg),
                                                    a(str("minimum-transmit-interval"), arg),
                                                    a(str("minimum-receive-interval"), arg),
                                                    a(str("multiplier"), arg),
                                                    c(
                                                      str("no-adaptation")
                                                    ),
                                                    b(str("transmit-interval"),
                                                        c(
                                                            a(str("minimum-interval"), arg),
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("detection-time"),
                                                        c(
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("authentication"),
                                                        c(
                                                            a(str("key-chain"), arg),
                                                            b(str("algorithm"),
                                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                            ),
                                                            str("loose-check")
                                                        )
                                                    ),
                                                    b(str("neighbor"),
                                                      ipaddr
                                                    ),
                                                    b(str("local-address"),
                                                      ipaddr
                                                    ),
                                                    a(str("holddown-interval"), arg)
                                                )
                                            ),
                                            a(str("minimum-links"), arg),
                                            b(str("minimum-bandwidth"),
                                                c(
                                                    a(str("bw-value"), arg),
                                                    b(str("bw-unit"),
                                                      (str("bps") | str("kbps") | str("mbps") | str("gbps"))
                                                    )
                                                )
                                            ),
                                            b(str("targeted-options"),
                                                c(
                                                    b(str("type"),
                                                      (str("auto") | str("manual"))
                                                    ),
                                                    c(
                                                      str("logical-interface-fpc-redundancy"),
                                                      str("logical-interface-chassis-redundancy")
                                                    ),
                                                    b(str("rebalance-periodic"),
                                                        c(
                                                            b(str("start-time"),
                                                              date
                                                            ),
                                                            a(str("interval"), arg)
                                                        )
                                                    ),
                                                    a(str("rebalance-subscriber-granularity"), arg)
                                                )
                                            ),
                                            c(
                                              str("logical-interface-fpc-redundancy"),
                                              str("logical-interface-chassis-redundancy")
                                            ),
                                            b(str("rebalance-periodic"),
                                                c(
                                                    b(str("start-time"),
                                                      date
                                                    ),
                                                    a(str("interval"), arg)
                                                )
                                            ),
                                            str("pad-to-minimum-frame-size"),
                                            b(str("link-speed"),
                                              (str("10m") | str("100m") | str("1g") | str("2.5g") | str("5g") | str("8g") | str("10g") | str("25g") | str("40g") | str("50g") | str("80g") | str("100g") | str("400g") | str("oc192") | str("mixed"))
                                            ),
                                            b(str("local-bias"),
                                                c(
                                                    str("disable")
                                                )
                                            ),
                                            a(str("local-minimum-links-threshold"), arg),
                                            str("resilient-hash"),
                                            b(str("lacp"),
                                                c(
                                                    c(
                                                      str("active"),
                                                      str("passive")
                                                    ),
                                                    b(str("periodic"),
                                                      (str("fast") | str("slow"))
                                                    ),
                                                    str("fast-failover"),
                                                    b(str("link-protection"),
                                                        c(
                                                            str("disable"),
                                                            c(
                                                              str("revertive"),
                                                              str("non-revertive")
                                                            ),
                                                            b(str("rtg-config"),
                                                                c(
                                                                    a(str("preempt-cutover-timer"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    str("accept-data"),
                                                    b(str("sync-reset"),
                                                      (str("disable") | str("enable"))
                                                    ),
                                                    a(str("system-priority"), arg),
                                                    b(str("system-id"),
                                                      mac_addr
                                                    ),
                                                    a(str("admin-key"), arg),
                                                    b(str("hold-time"),
                                                        sc(
                                                            a(str("up"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    a(str("aggregate-wait-time"), arg),
                                                    str("force-up"),
                                                    str("no-peer-loopback-validation")
                                                )
                                            ),
                                            b(a(str("link-protection-sub-group"), arg),
                                                c(
                                                    c(
                                                      str("primary"),
                                                      str("backup")
                                                    )
                                                )
                                            ),
                                            b(str("ethernet-switch-profile"),
                                                c(
                                                    a(str("tag-protocol-id"), arg),
                                                    b(str("storm-control"),
                                                        c(
                                                            arg
                                                        )
                                                    ),
                                                    str("mac-learn-enable")
                                                )
                                            ),
                                            b(str("mc-ae"),
                                                c(
                                                    a(str("mc-ae-id"), arg),
                                                    a(str("redundancy-group"), arg),
                                                    a(str("chassis-id"), arg),
                                                    b(str("mode"),
                                                      (str("active-standby") | str("active-active"))
                                                    ),
                                                    b(str("status-control"),
                                                      (str("active") | str("standby"))
                                                    ),
                                                    b(str("switchover-mode"),
                                                      (str("revertive") | str("non-revertive"))
                                                    ),
                                                    a(str("revert-time"), arg),
                                                    a(str("init-delay-time"), arg),
                                                    a(str("recovery-delay-time"), arg),
                                                    str("enhanced-convergence"),
                                                    b(str("events"),
                                                        c(
                                                            b(str("iccp-peer-down"),
                                                                c(
                                                                    str("force-icl-down"),
                                                                    str("prefer-status-control-active")
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            str("share-standby")
                                        )
                                    ),
                                    b(str("es-options"),
                                        c(
                                            b(str("backup-interface"),
                                              interface_device
                                            )
                                        )
                                    ),
                                    b(str("dsl-options"),
                                        c(
                                            b(str("operating-mode"),
                                              (str("auto") | str("ansi-dmt") | str("itu-dmt") | str("etsi") | str("itu-annexb-ur2") | str("itu-annexb-non-ur2") | str("itu-dmt-bis") | str("adsl2plus") | str("annexm-itu-dmt-bis") | str("annexm-adsl2plus"))
                                            )
                                        )
                                    ),
                                    b(str("vdsl-options"),
                                        c(
                                            b(str("vdsl-profile"),
                                              (str("auto") | str("8a") | str("8b") | str("8c") | str("8d") | str("12a") | str("12b") | str("17a"))
                                            ),
                                            b(str("sra"),
                                              (str("enable") | str("disable"))
                                            ),
                                            b(str("v43"),
                                              (str("enable") | str("disable"))
                                            ),
                                            str("sos")
                                        )
                                    ),
                                    b(str("dsl-sfp-options"),
                                        c(
                                            b(str("adsl-options"),
                                                c(
                                                    a(str("vpi"), arg),
                                                    a(str("vci"), arg),
                                                    b(str("encap"),
                                                      (str("bypass") | str("llcsnap-bridged-802dot1q") | str("llcsnap-routed-ip") | str("vc-mux-bridged") | str("vc-mux-routed-ip") | str("generic"))
                                                    )
                                                )
                                            ),
                                            b(str("vdsl-options"),
                                                c(
                                                    b(str("profile"),
                                                      (str("auto") | str("8a") | str("8b") | str("8c") | str("8d") | str("12a") | str("12b") | str("17a") | str("30a"))
                                                    ),
                                                    b(str("carrier"),
                                                      (str("auto") | str("a43") | str("b43"))
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("shdsl-options"),
                                        c(
                                            b(str("annex"),
                                              (str("annex-a") | str("annex-b") | str("annex-f") | str("annex-g") | str("annex-auto"))
                                            ),
                                            b(str("line-rate"),
                                              (str("auto") | arg)
                                            ),
                                            b(str("loopback"),
                                              (str("local") | str("remote"))
                                            ),
                                            b(str("snr-margin"),
                                                c(
                                                    b(str("current"),
                                                      (str("disable") | arg)
                                                    ),
                                                    b(str("snext"),
                                                      (str("disable") | arg)
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("data-input"),
                                        c(
                                            c(
                                              str("system"),
                                              b(str("interface"),
                                                interface_device
                                              )
                                            )
                                        )
                                    ),
                                    b(str("switch-options"),
                                        c(
                                            b(a(str("switch-port"), arg),
                                                c(
                                                    str("auto-negotiation"),
                                                    str("no-auto-negotiation"),
                                                    b(str("link-mode"),
                                                      (str("half-duplex") | str("full-duplex"))
                                                    ),
                                                    b(str("speed"),
                                                      (str("10m") | str("100m") | str("1g"))
                                                    ),
                                                    a(str("vlan-id"), arg),
                                                    str("cascade-port")
                                                )
                                            )
                                        )
                                    ),
                                    b(str("container-options"),
                                        c(
                                            b(str("container-type"),
                                                c(
                                                    c(
                                                      b(str("aps"),
                                                        aps_type
                                                      )
                                                    )
                                                )
                                            ),
                                            b(str("member-interface-type"),
                                                c(
                                                    c(
                                                      b(str("sonet"),
                                                          c(
                                                              b(str("member-interface-speed"),
                                                                (str("oc3") | str("oc12") | str("oc48") | str("oc192") | str("oc768") | str("mixed"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("atm"),
                                                          c(
                                                              b(str("member-interface-speed"),
                                                                (str("oc3") | str("oc12") | str("oc48"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("channelized-sonet"),
                                                          c(
                                                              b(str("member-interface-speed"),
                                                                (str("coc3") | str("coc12") | str("coc48") | str("coc192") | str("coc768"))
                                                              )
                                                          )
                                                      ),
                                                      b(str("channelized-sdh"),
                                                          c(
                                                              b(str("member-interface-speed"),
                                                                (str("cstm1") | str("cstm4") | str("cstm16") | str("coc64") | str("cstm256"))
                                                              )
                                                          )
                                                      )
                                                    )
                                                )
                                            ),
                                            b(str("redundancy"),
                                                c(
                                                    b(str("hold-time"),
                                                        sc(
                                                            a(str("up"), arg),
                                                            a(str("down"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(str("container-list"),
                                              interface_device
                                            ),
                                            c(
                                                str("primary"),
                                                str("standby")
                                            ),
                                            str("fast-aps"),
                                            str("allow-configuration-override")
                                        )
                                    ),
                                    b(str("layer2-policer"),
                                        c(
                                            c(
                                              a(str("input-policer"), arg),
                                              a(str("input-hierarchical-policer"), arg)
                                            )
                                        )
                                    ),
                                    a(str("unit"), enum(arg | arg | arg),
                                        c(
                                            b(str("policer-overhead"),
                                                ca(
                                                    a(str("ingress"), arg),
                                                    a(str("egress"), arg)
                                                )
                                            ),
                                            a(str("alias"), arg),
                                            str("enhanced-convergence"),
                                            str("proxy-macip-advertisement"),
                                            str("virtual-gateway-accept-data"),
                                            b(str("peer-psd"),
                                                sc(
                                                    arg
                                                )
                                            ).as(:oneline),
                                            b(str("peer-interface"),
                                                c(
                                                      interface_unit
                                                )
                                            ),
                                            b(str("interface-shared-with"),
                                                c(
                                                    arg
                                                )
                                            ),
                                              (str("disable")),
                                            str("passive-monitor-mode"),
                                            str("per-session-scheduler"),
                                            b(str("account-layer2-overhead"),
                                                ca(
                                                    a(str("ingress"), arg),
                                                    a(str("egress"), arg)
                                                )
                                            ),
                                            b(str("forwarding-class-accounting"),
                                                c(
                                                    b(str("direction"),
                                                      (str("ingress") | str("egress") | str("both"))
                                                    ),
                                                    b(str("enhanced"),
                                                        c(
                                                            b(str("traffic-type"),
                                                              (str("unicast-statistics") | str("multicast-statistics"))
                                                            ),
                                                            b(str("family"),
                                                              (str("inet6") | str("inet") | str("both"))
                                                            ),
                                                            b(str("direction"),
                                                              (str("ingress") | str("egress") | str("both"))
                                                            ),
                                                            a(str("overhead-bytes"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            str("clear-dont-fragment-bit"),
                                            str("packet-inject-enable"),
                                            str("reassemble-packets"),
                                            str("services-options"),
                                            b(str("rpm"),
                                                c(
                                                    c(
                                                      c(
                                                        str("client"),
                                                        str("server"),
                                                        str("client-delegate-probes")
                                                      ),
                                                      str("twamp-server"),
                                                      str("twamp-client")
                                                    )
                                                )
                                            ),
                                            a(str("description"), quote | arg),
                                            a(str("metadata"), arg),
                                            b(str("dial-options"),
                                                c(
                                                    c(
                                                      a(str("l2tp-interface-id"), arg),
                                                      a(str("ipsec-interface-id"), arg)
                                                    ),
                                                    c(
                                                      str("dedicated"),
                                                      str("shared")
                                                    )
                                                )
                                            ),
                                            str("actual-transit-statistics"),
                                            b(str("demux-source"),
                                                  enum((str("inet6") | str("inet")))
                                            ),
                                            b(str("demux-destination"),
                                                  enum((str("inet6") | str("inet")))
                                            ),
                                            b(str("demux"),
                                                c(
                                                    b(str("inet"),
                                                        c(
                                                            b(str("address"),
                                                              (str("source") | str("destination"))
                                                            ),
                                                            b(str("auto-configure"),
                                                              dynamic_ipv4_type
                                                            )
                                                        )
                                                    ),
                                                    b(str("inet6"),
                                                        c(
                                                            b(str("address"),
                                                              (str("source") | str("destination"))
                                                            ),
                                                            b(str("auto-configure"),
                                                              dynamic_ipv6_type
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("encapsulation"),
                                              (str("atm-nlpid") | str("atm-cisco-nlpid") | str("atm-snap") | str("atm-vc-mux") | str("atm-ccc-vc-mux") | str("atm-tcc-vc-mux") | str("atm-tcc-snap") | str("atm-ccc-cell-relay") | str("vlan-vci-ccc") | str("ether-over-atm-llc") | str("ether-vpls-over-atm-llc") | str("ppp-over-ether-over-atm-llc") | str("ppp-over-ether") | str("atm-ppp-vc-mux") | str("atm-ppp-llc") | str("atm-mlppp-llc") | str("frame-relay-ppp") | str("frame-relay-ccc") | str("frame-relay") | str("frame-relay-tcc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("ether-vpls-fr") | str("vlan-ccc") | str("ethernet-ccc") | str("vlan-vpls") | str("vlan-bridge") | str("dix") | str("ethernet-vpls") | str("ethernet-bridge") | str("ethernet") | str("vlan") | str("vlan-tcc") | str("multilink-ppp") | str("multilink-frame-relay-end-to-end") | str("ppp-ccc"))
                                            ),
                                            str("gre"),
                                            a(str("mtu"), arg),
                                            c(
                                              str("point-to-point"),
                                              str("multipoint")
                                            ),
                                            a(str("bandwidth"), arg),
                                            a(str("global-layer2-domainid"), arg),
                                            b(str("radio-router"),
                                              dynamic_ifbw_parms_type
                                            ),
                                            str("traps"),
                                            str("no-traps"),
                                            str("routing-services"),
                                            str("no-routing-services"),
                                            b(str("routing-service"),
                                                c(
                                                      (str("enable") | str("disable"))
                                                )
                                            ),
                                            b(str("arp-resp"),
                                                sc(
                                                    c(
                                                      str("unrestricted"),
                                                      str("restricted")
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("proxy-arp"),
                                                sc(
                                                    c(
                                                      str("unrestricted"),
                                                      str("restricted")
                                                    )
                                                )
                                            ).as(:oneline),
                                            c(
                                              b(str("vlan-id"),
                                                (str("none") | arg)
                                              ),
                                              a(str("vlan-id-range"), arg),
                                              a(str("inner-vlan-id-swap-ranges"), arg),
                                              a(str("vlan-id-list"), arg),
                                              a(str("vlan-tag"), arg),
                                              b(str("vlan-tags"),
                                                  sc(
                                                      b(str("outer"),
                                                        (arg | arg | arg)
                                                      ),
                                                      c(
                                                        b(str("inner"),
                                                          (arg | arg)
                                                        ),
                                                        a(str("inner-range"), arg),
                                                        a(str("inner-list"), arg)
                                                      )
                                                  )
                                              ).as(:oneline)
                                            ),
                                            a(str("deep-vlan-qualified-learning"), arg),
                                            a(str("native-inner-vlan-id"), arg),
                                            b(str("inner-vlan-id-range"),
                                                sc(
                                                    a(str("start"), arg),
                                                    a(str("end"), arg)
                                                )
                                            ).as(:oneline),
                                            b(str("accept-source-mac"),
                                                c(
                                                    b(str("mac-address"),
                                                      mac_list
                                                    )
                                                )
                                            ),
                                            b(str("input-vlan-map"),
                                              vlan_map
                                            ),
                                            b(str("output-vlan-map"),
                                              vlan_map
                                            ),
                                            str("swap-by-poppush"),
                                            a(str("receive-lsp"), arg),
                                            a(str("transmit-lsp"), arg),
                                            a(str("dlci"), arg),
                                            a(str("multicast-dlci"), arg),
                                            c(
                                              b(str("vci"),
                                                atm_vci
                                              ),
                                              str("allow-any-vci"),
                                              a(str("vpi"), arg),
                                              a(str("trunk-id"), arg)
                                            ),
                                            str("no-vpivci-swapping"),
                                            c(
                                              b(str("psn-vci"),
                                                atm_vci
                                              ),
                                              a(str("psn-vpi"), arg)
                                            ),
                                            b(str("atm-l2circuit-mode"),
                                                sc(
                                                    c(
                                                      str("cell"),
                                                      str("aal5")
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("vci-range"),
                                                sc(
                                                    a(str("start"), arg),
                                                    a(str("end"), arg)
                                                )
                                            ).as(:oneline),
                                            a(str("trunk-bandwidth"), arg),
                                            b(str("multicast-vci"),
                                              atm_vci
                                            ),
                                            b(str("shaping"),
                                              dcd_shaping_config
                                            ),
                                            b(str("oam-period"),
                                                sc(
                                                    ca(
                                                      str("disable").as(:oneline)
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("oam-liveness"),
                                                c(
                                                    a(str("up-count"), arg),
                                                    a(str("down-count"), arg)
                                                )
                                            ),
                                            b(str("ppp-options"),
                                              ppp_options_type
                                            ),
                                            b(str("pppoe-options"),
                                              pppoe_options_type
                                            ),
                                            b(str("pppoe-underlying-options"),
                                              pppoe_underlying_options_type
                                            ),
                                            b(str("advisory-options"),
                                              advisory_options_type
                                            ),
                                            b(str("auto-configure"),
                                              auto_configure_vlan_type
                                            ),
                                            b(str("demux-options"),
                                              demux_options_type
                                            ),
                                            b(str("targeted-distribution"),
                                                c(
                                                    a(str("primary-list"), arg),
                                                    a(str("backup-list"), arg),
                                                    a(str("standby-list"), arg)
                                                )
                                            ),
                                            b(str("targeted-options"),
                                                c(
                                                    b(str("weight"),
                                                      (arg | arg)
                                                    ),
                                                    b(str("primary"),
                                                      interface_device
                                                    ),
                                                    b(str("backup"),
                                                      interface_device
                                                    ),
                                                    a(str("group"), arg)
                                                )
                                            ),
                                            c(
                                              b(str("keepalives"),
                                                keepalives_type
                                              ).as(:oneline),
                                              str("no-keepalives")
                                            ),
                                            str("inverse-arp"),
                                            a(str("transmit-weight"), arg),
                                            b(str("epd-threshold"),
                                              epd_threshold_config
                                            ).as(:oneline),
                                            a(str("cell-bundle-size"), arg),
                                            a(str("cell-bundle-timeout"), arg),
                                            str("plp-to-clp"),
                                            a(str("atm-scheduler-map"), arg),
                                            a(str("mrru"), arg),
                                            str("short-sequence"),
                                            a(str("fragment-threshold"), arg),
                                            a(str("drop-timeout"), arg),
                                            str("disable-mlppp-inner-ppp-pfc"),
                                            a(str("minimum-links"), arg),
                                            a(str("multilink-max-classes"), arg),
                                            b(str("compression"),
                                                c(
                                                    b(str("rtp"),
                                                        c(
                                                            a(str("f-max-period"), arg),
                                                            b(str("queues"),
                                                              (str("q0") | str("q1") | str("q2") | str("q3"))
                                                            ),
                                                            b(str("port"),
                                                                sc(
                                                                    a(str("minimum"), arg),
                                                                    a(str("maximum"), arg)
                                                                )
                                                            ).as(:oneline),
                                                            b(str("maximum-contexts"),
                                                                sc(
                                                                      arg
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            str("interleave-fragments"),
                                            b(str("link-layer-overhead"),
                                              unsigned_float
                                            ),
                                            a(str("accounting-profile"), arg),
                                            a(str("peer-unit"), arg),
                                            b(str("tunnel"),
                                                c(
                                                    b(str("encapsulation"),
                                                        c(
                                                            b(str("vxlan-gpe"),
                                                                c(
                                                                    b(str("source"),
                                                                        c(
                                                                            b(str("address"),
                                                                              ipv4addr
                                                                            ),
                                                                            b(str("interface"),
                                                                              interface_name
                                                                            )
                                                                        )
                                                                    ),
                                                                    b(str("destination"),
                                                                        c(
                                                                            b(str("address"),
                                                                              ipv4addr
                                                                            )
                                                                        )
                                                                    ),
                                                                    b(str("tunnel-endpoint"),
                                                                      (str("vxlan"))
                                                                    ),
                                                                    a(str("destination-udp-port"), arg),
                                                                    a(str("vni"), arg)
                                                                )
                                                            ),
                                                            b(str("udp"),
                                                                c(
                                                                    b(str("source"),
                                                                        c(
                                                                            b(str("address"),
                                                                              ipv4addr
                                                                            ),
                                                                            b(str("interface"),
                                                                              interface_name
                                                                            )
                                                                        )
                                                                    ),
                                                                    b(str("destination"),
                                                                        c(
                                                                            b(str("address"),
                                                                              ipv4addr
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("source"),
                                                      ipaddr
                                                    ),
                                                    b(str("destination"),
                                                      ipaddr
                                                    ),
                                                    a(str("key"), arg),
                                                    b(str("backup-destination"),
                                                      ipaddr
                                                    ),
                                                    c(
                                                      str("allow-fragmentation"),
                                                      str("do-not-fragment")
                                                    ),
                                                    a(str("ttl"), arg),
                                                    a(str("traffic-class"), arg),
                                                    a(str("flow-label"), arg),
                                                    str("path-mtu-discovery"),
                                                    str("no-path-mtu-discovery"),
                                                    b(str("routing-instance"),
                                                        c(
                                                            a(str("destination"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("compression-device"),
                                              interface_unit
                                            ),
                                            b(str("atm-policer"),
                                                c(
                                                    a(str("input-atm-policer"), arg)
                                                )
                                            ),
                                            b(str("layer2-policer"),
                                                c(
                                                    c(
                                                      a(str("input-policer"), arg),
                                                      a(str("input-hierarchical-policer"), arg),
                                                      a(str("input-three-color"), arg)
                                                    ),
                                                    c(
                                                      b(str("output-policer"),
                                                        (arg | arg)
                                                      ),
                                                      b(str("output-three-color"),
                                                        (arg | arg)
                                                      )
                                                    )
                                                )
                                            ),
                                            b(str("filter"),
                                                c(
                                                    c(
                                                      b(str("input"),
                                                          sc(
                                                              arg,
                                                              a(str("shared-name"), arg),
                                                              a(str("precedence"), arg)
                                                          )
                                                      ).as(:oneline)
                                                    ),
                                                    c(
                                                      b(str("output"),
                                                          sc(
                                                              arg,
                                                              a(str("shared-name"), arg),
                                                              a(str("precedence"), arg)
                                                          )
                                                      ).as(:oneline)
                                                    )
                                                )
                                            ),
                                            b(str("multi-chassis-protection"),
                                              multi_chassis_protection_group_ifl
                                            ),
                                            str("statistics"),
                                            b(str("esi"),
                                                c(
                                                    b(str("auto-derive"),
                                                        c(
                                                            c(
                                                              str("lacp")
                                                            )
                                                        )
                                                    ),
                                                      esi,
                                                    c(
                                                      str("single-active"),
                                                      str("all-active")
                                                    ),
                                                    b(str("df-election-type"),
                                                        c(
                                                            c(
                                                              b(str("preference"),
                                                                  c(
                                                                      a(str("value"), arg)
                                                                  )
                                                              )
                                                            ),
                                                            c(
                                                              str("mod")
                                                            )
                                                        )
                                                    ),
                                                    b(str("source-bmac"),
                                                      mac_unicast
                                                    )
                                                )
                                            ),
                                            c(
                                              str("no-auto-virtual-gateway-esi"),
                                              b(str("virtual-gateway-esi"),
                                                  c(
                                                        esi,
                                                      c(
                                                        str("single-active"),
                                                        str("all-active")
                                                      )
                                                  )
                                              )
                                            ),
                                            b(str("service"),
                                                c(
                                                    b(a(str("pcef"), arg),
                                                        c(
                                                            str("activate-all"),
                                                            a(str("activate"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            str("generate-eui64"),
                                            str("no-generate-eui64"),
                                            b(str("family"),
                                                c(
                                                    b(str("inet"),
                                                        c(
                                                            b(str("dhcp"),
                                                              dhcp_client_type
                                                            ),
                                                            b(str("targeted-broadcast"),
                                                                c(
                                                                    c(
                                                                      str("forward-and-send-to-re"),
                                                                      str("forward-only")
                                                                    )
                                                                )
                                                            ),
                                                            str("destination-class-usage"),
                                                            str("transit-options-packets"),
                                                            str("transit-ttl-exceeded"),
                                                            str("receive-options-packets"),
                                                            str("receive-ttl-exceeded"),
                                                            b(str("accounting"),
                                                                c(
                                                                    b(str("source-class-usage"),
                                                                        c(
                                                                            str("input"),
                                                                            str("output")
                                                                        )
                                                                    ),
                                                                    str("destination-class-usage")
                                                                )
                                                            ),
                                                            b(str("mac-validate"),
                                                              (str("strict") | str("loose"))
                                                            ),
                                                            b(str("rpf-check"),
                                                                c(
                                                                    a(str("fail-filter"), arg),
                                                                    b(str("mode"),
                                                                        sc(
                                                                            str("loose")
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            ),
                                                            a(str("mtu"), arg),
                                                            a(str("arp-max-cache"), arg),
                                                            a(str("arp-new-hold-limit"), arg),
                                                            a(str("tcp-mss"), arg),
                                                            str("no-redirects"),
                                                            str("no-neighbor-learn"),
                                                            str("unconditional-src-learn"),
                                                            str("multicast-only"),
                                                            str("primary"),
                                                            a(str("ipsec-sa"), arg),
                                                            str("allow-filter-on-re"),
                                                            a(str("demux-source"), arg | arg),
                                                            a(str("demux-destination"), arg | arg),
                                                            b(str("filter"),
                                                                c(
                                                                    c(
                                                                      b(str("input"),
                                                                          sc(
                                                                              arg,
                                                                              a(str("shared-name"), arg),
                                                                              a(str("precedence"), arg)
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("input-list"), arg)
                                                                    ),
                                                                    a(str("input-chain"), arg),
                                                                    a(str("output-chain"), arg),
                                                                    c(
                                                                      b(str("output"),
                                                                          sc(
                                                                              arg,
                                                                              a(str("shared-name"), arg),
                                                                              a(str("precedence"), arg)
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("output-list"), arg)
                                                                    ),
                                                                    b(str("adf"),
                                                                        c(
                                                                            a(str("rule"), arg),
                                                                            str("counter"),
                                                                            a(str("input-precedence"), arg),
                                                                            str("not-mandatory"),
                                                                            a(str("output-precedence"), arg)
                                                                        )
                                                                    ),
                                                                    a(str("group"), arg)
                                                                )
                                                            ),
                                                            b(str("ingress-queuing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            b(str("iq-policing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            b(str("simple-filter"),
                                                                c(
                                                                    a(str("input"), arg)
                                                                )
                                                            ),
                                                            a(str("input-hierarchical-policer"), arg),
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("arp"), arg),
                                                                    a(str("input"), arg),
                                                                    a(str("output"), arg)
                                                                )
                                                            ),
                                                            b(str("sampling"),
                                                                c(
                                                                    str("input"),
                                                                    str("output")
                                                                )
                                                            ),
                                                            b(str("service"),
                                                                c(
                                                                    b(str("input"),
                                                                        c(
                                                                            b(a(str("service-set"), arg),
                                                                                c(
                                                                                    a(str("service-filter"), arg)
                                                                                )
                                                                            ),
                                                                            a(str("post-service-filter"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("output"),
                                                                        c(
                                                                            b(a(str("service-set"), arg),
                                                                                c(
                                                                                    a(str("service-filter"), arg)
                                                                                )
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            b(a(str("next-hop-tunnel"), arg),
                                                                c(
                                                                    a(str("ipsec-vpn"), arg)
                                                                )
                                                            ),
                                                            b(a(str("address"), arg),
                                                                c(
                                                                    b(str("destination"),
                                                                      ipv4addr
                                                                    ),
                                                                    a(str("destination-profile"), arg),
                                                                    b(str("broadcast"),
                                                                      ipv4addr
                                                                    ),
                                                                    str("primary"),
                                                                    str("preferred"),
                                                                    str("master-only"),
                                                                    b(a(str("multipoint-destination"), arg),
                                                                        c(
                                                                            c(
                                                                              a(str("dlci"), arg),
                                                                              b(str("vci"),
                                                                                atm_vci
                                                                              )
                                                                            ),
                                                                            b(str("shaping"),
                                                                              dcd_shaping_config
                                                                            ),
                                                                            b(str("oam-period"),
                                                                                sc(
                                                                                    ca(
                                                                                      str("disable").as(:oneline)
                                                                                    )
                                                                                )
                                                                            ).as(:oneline),
                                                                            b(str("oam-liveness"),
                                                                                c(
                                                                                    a(str("up-count"), arg),
                                                                                    a(str("down-count"), arg)
                                                                                )
                                                                            ),
                                                                            str("inverse-arp"),
                                                                            a(str("transmit-weight"), arg),
                                                                            b(str("epd-threshold"),
                                                                              epd_threshold_config
                                                                            ).as(:oneline)
                                                                        )
                                                                    ),
                                                                    b(a(str("arp"), arg),
                                                                        sc(
                                                                            b(str("l2-interface"),
                                                                              interface_name
                                                                            ),
                                                                            c(
                                                                              b(str("mac"),
                                                                                mac_unicast
                                                                              ),
                                                                              b(str("multicast-mac"),
                                                                                mac_multicast
                                                                              )
                                                                            ),
                                                                            str("publish")
                                                                        )
                                                                    ).as(:oneline),
                                                                    b(a(str("host-discovery"), arg),
                                                                        sc(
                                                                            a(str("aging-timer"), arg),
                                                                            a(str("discovery-interval"), arg)
                                                                        )
                                                                    ).as(:oneline),
                                                                    b(str("web-authentication"),
                                                                        c(
                                                                            str("https"),
                                                                            str("http"),
                                                                            str("redirect-to-https")
                                                                        )
                                                                    ),
                                                                    b(str("vrrp-group"),
                                                                      vrrp_group
                                                                    ),
                                                                    b(str("virtual-gateway-address"),
                                                                      ipv4addr
                                                                    )
                                                                )
                                                            ),
                                                            b(str("unnumbered-address"),
                                                                sc(
                                                                      interface_unit,
                                                                    b(str("preferred-source-address"),
                                                                      (arg | arg)
                                                                    ),
                                                                    b(str("destination"),
                                                                      ipv4addr
                                                                    ),
                                                                    a(str("destination-profile"), arg)
                                                                )
                                                            ).as(:oneline),
                                                            b(str("location-pool-address"),
                                                                c(
                                                                      arg
                                                                )
                                                            ),
                                                            str("negotiate-address"),
                                                            a(str("destination-udp-port"), arg)
                                                        )
                                                    ),
                                                    b(str("iso"),
                                                        c(
                                                            a(str("address"), arg),
                                                            a(str("mtu"), arg),
                                                            a(str("destination-udp-port"), arg)
                                                        )
                                                    ),
                                                    b(str("inet6"),
                                                        c(
                                                            b(str("dhcpv6-client"),
                                                                c(
                                                                    b(str("client-type"),
                                                                      (str("stateful") | str("autoconfig"))
                                                                    ),
                                                                    a(str("client-ia-type"), enum(str("ia-na") | str("ia-pd"))),
                                                                    str("rapid-commit"),
                                                                    b(str("prefix-delegating"),
                                                                        c(
                                                                            a(str("preferred-prefix-length"), arg),
                                                                            a(str("sub-prefix-length"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("client-identifier"),
                                                                        sc(
                                                                            b(str("duid-type"),
                                                                              (str("duid-llt") | str("vendor") | str("duid-ll"))
                                                                            )
                                                                        )
                                                                    ).as(:oneline),
                                                                    a(str("req-option"), enum(str("dns-server") | str("domain") | str("ntp-server") | str("time-zone") | str("sip-server") | str("sip-domain") | str("nis-server") | str("nis-domain") | str("fqdn") | str("vendor-spec") | str("zero-touch-redirect"))),
                                                                    b(str("options"),
                                                                        c(
                                                                            b(a(str("number"), arg),
                                                                                sc(
                                                                                    c(
                                                                                      a(str("hex-string"), arg)
                                                                                    )
                                                                                )
                                                                            ).as(:oneline)
                                                                        )
                                                                    ),
                                                                    a(str("retransmission-attempt"), arg),
                                                                    str("no-dns-install"),
                                                                    b(str("update-router-advertisement"),
                                                                        c(
                                                                            b(a(str("interface"), arg),
                                                                                c(
                                                                                    str("managed-configuration"),
                                                                                    str("no-managed-configuration"),
                                                                                    str("other-stateful-configuration"),
                                                                                    str("no-other-stateful-configuration"),
                                                                                    a(str("max-advertisement-interval"), arg),
                                                                                    a(str("min-advertisement-interval"), arg),
                                                                                    str("enable-recursive-dns-server-option"),
                                                                                    str("no-enable-recursive-dns-server-option")
                                                                                )
                                                                            )
                                                                        )
                                                                    ),
                                                                    str("update-server")
                                                                )
                                                            ),
                                                            b(str("rpf-check"),
                                                                c(
                                                                    a(str("fail-filter"), arg),
                                                                    b(str("mode"),
                                                                        sc(
                                                                            str("loose")
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            ),
                                                            b(str("accounting"),
                                                                c(
                                                                    b(str("source-class-usage"),
                                                                        c(
                                                                            str("input"),
                                                                            str("output")
                                                                        )
                                                                    ),
                                                                    str("destination-class-usage")
                                                                )
                                                            ),
                                                            a(str("mtu"), arg),
                                                            a(str("tcp-mss"), arg),
                                                            a(str("nd6-stale-time"), arg),
                                                            str("no-neighbor-learn"),
                                                            str("slaac-enable"),
                                                            b(str("ndp-proxy"),
                                                                c(
                                                                    str("interface-restricted")
                                                                )
                                                            ),
                                                            b(str("dad-proxy"),
                                                                c(
                                                                    str("interface-restricted")
                                                                )
                                                            ),
                                                            a(str("nd6-max-cache"), arg),
                                                            a(str("nd6-new-hold-limit"), arg),
                                                            str("no-redirects"),
                                                            str("allow-filter-on-re"),
                                                            b(str("filter"),
                                                                c(
                                                                    c(
                                                                      b(str("input"),
                                                                          sc(
                                                                              arg,
                                                                              a(str("shared-name"), arg),
                                                                              a(str("precedence"), arg)
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("input-list"), arg)
                                                                    ),
                                                                    c(
                                                                      b(str("output"),
                                                                          sc(
                                                                              arg,
                                                                              a(str("shared-name"), arg),
                                                                              a(str("precedence"), arg)
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("output-list"), arg)
                                                                    ),
                                                                    a(str("input-chain"), arg),
                                                                    a(str("output-chain"), arg),
                                                                    b(str("adf"),
                                                                        c(
                                                                            a(str("rule"), arg),
                                                                            str("counter"),
                                                                            a(str("input-precedence"), arg),
                                                                            str("not-mandatory"),
                                                                            a(str("output-precedence"), arg)
                                                                        )
                                                                    ),
                                                                    a(str("group"), arg)
                                                                )
                                                            ),
                                                            b(str("ingress-queuing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            a(str("input-hierarchical-policer"), arg),
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("input"), arg),
                                                                    a(str("output"), arg)
                                                                )
                                                            ),
                                                            b(str("sampling"),
                                                                c(
                                                                    str("input"),
                                                                    str("output")
                                                                )
                                                            ),
                                                            b(str("service"),
                                                                c(
                                                                    b(str("input"),
                                                                        c(
                                                                            b(a(str("service-set"), arg),
                                                                                c(
                                                                                    a(str("service-filter"), arg)
                                                                                )
                                                                            ),
                                                                            a(str("post-service-filter"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("output"),
                                                                        c(
                                                                            b(a(str("service-set"), arg),
                                                                                c(
                                                                                    a(str("service-filter"), arg)
                                                                                )
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            b(a(str("address"), arg),
                                                                c(
                                                                    b(str("destination"),
                                                                      ipv6addr
                                                                    ),
                                                                    str("eui-64"),
                                                                    str("primary"),
                                                                    str("preferred"),
                                                                    str("master-only"),
                                                                    b(a(str("ndp"), arg),
                                                                        sc(
                                                                            b(str("l2-interface"),
                                                                              interface_name
                                                                            ),
                                                                            c(
                                                                              b(str("mac"),
                                                                                mac_unicast
                                                                              ),
                                                                              b(str("multicast-mac"),
                                                                                mac_multicast
                                                                              )
                                                                            ),
                                                                            str("publish")
                                                                        )
                                                                    ).as(:oneline),
                                                                    b(str("vrrp-inet6-group"),
                                                                      vrrp_group
                                                                    ),
                                                                    b(str("web-authentication"),
                                                                        c(
                                                                            str("https"),
                                                                            str("http"),
                                                                            str("redirect-to-https")
                                                                        )
                                                                    ),
                                                                    b(str("virtual-gateway-address"),
                                                                      ipv6addr
                                                                    ),
                                                                    str("subnet-router-anycast")
                                                                )
                                                            ),
                                                            a(str("demux-source"), arg | arg | arg),
                                                            a(str("demux-destination"), arg | arg),
                                                            b(str("unnumbered-address"),
                                                                sc(
                                                                      interface_unit,
                                                                    b(str("preferred-source-address"),
                                                                      (arg | arg)
                                                                    )
                                                                )
                                                            ).as(:oneline),
                                                            str("dad-disable"),
                                                            str("no-dad-disable"),
                                                            a(str("destination-udp-port"), arg)
                                                        )
                                                    ),
                                                    b(str("mpls"),
                                                        c(
                                                            a(str("mtu"), arg),
                                                            a(str("maximum-labels"), arg),
                                                            b(str("filter"),
                                                                c(
                                                                    c(
                                                                      a(str("input"), arg),
                                                                      a(str("input-list"), arg)
                                                                    ),
                                                                    a(str("input-chain"), arg),
                                                                    c(
                                                                      a(str("output"), arg),
                                                                      a(str("output-list"), arg)
                                                                    ),
                                                                    a(str("output-chain"), arg),
                                                                    a(str("group"), arg)
                                                                )
                                                            ),
                                                            b(str("ingress-queuing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            a(str("input-hierarchical-policer"), arg),
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("input"), arg),
                                                                    a(str("output"), arg)
                                                                )
                                                            ),
                                                            a(str("destination-udp-port"), arg)
                                                        )
                                                    ),
                                                    b(str("mlppp"),
                                                        c(
                                                            b(str("bundle"),
                                                              (arg | arg)
                                                            ),
                                                            c(
                                                              b(str("service-interface"),
                                                                interface_device
                                                              ),
                                                              a(str("service-device-pool"), arg)
                                                            ),
                                                            a(str("dynamic-profile"), arg)
                                                        )
                                                    ),
                                                    b(str("mlfr-end-to-end"),
                                                        c(
                                                            b(str("bundle"),
                                                              interface_unit
                                                            )
                                                        )
                                                    ),
                                                    b(str("mlfr-uni-nni"),
                                                        c(
                                                            b(str("bundle"),
                                                              interface_unit
                                                            )
                                                        )
                                                    ),
                                                    b(str("ccc"),
                                                        c(
                                                            a(str("mtu"), arg),
                                                            b(str("filter"),
                                                                c(
                                                                    c(
                                                                      a(str("input"), arg),
                                                                      a(str("input-list"), arg)
                                                                    ),
                                                                    a(str("input-chain"), arg),
                                                                    c(
                                                                      a(str("output"), arg),
                                                                      a(str("output-list"), arg)
                                                                    ),
                                                                    a(str("output-chain"), arg),
                                                                    a(str("group"), arg)
                                                                )
                                                            ),
                                                            b(str("ingress-queuing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("input"), arg),
                                                                    a(str("output"), arg)
                                                                )
                                                            ),
                                                            str("translate-fecn-and-becn"),
                                                            c(
                                                              str("translate-discard-eligible"),
                                                              str("translate-plp-control-word-de")
                                                            ),
                                                            str("keep-address-and-control")
                                                        )
                                                    ),
                                                    b(str("tcc"),
                                                        c(
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("input"), arg),
                                                                    a(str("output"), arg)
                                                                )
                                                            ),
                                                            b(str("proxy"),
                                                                c(
                                                                    b(str("inet-address"),
                                                                      ipv4addr
                                                                    )
                                                                )
                                                            ),
                                                            b(str("remote"),
                                                                c(
                                                                    b(str("inet-address"),
                                                                      ipv4addr
                                                                    ),
                                                                    b(str("mac-address"),
                                                                      mac_addr
                                                                    )
                                                                )
                                                            ),
                                                            b(str("protocols"),
                                                              (str("mpls") | str("inet") | str("iso"))
                                                            )
                                                        )
                                                    ),
                                                    b(str("vpls"),
                                                        c(
                                                            str("core-facing"),
                                                            b(str("filter"),
                                                                c(
                                                                    c(
                                                                      b(str("input"),
                                                                          sc(
                                                                              arg,
                                                                              a(str("shared-name"), arg),
                                                                              a(str("precedence"), arg)
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("input-list"), arg)
                                                                    ),
                                                                    a(str("input-chain"), arg),
                                                                    a(str("output-chain"), arg),
                                                                    c(
                                                                      b(str("output"),
                                                                          sc(
                                                                              arg,
                                                                              a(str("shared-name"), arg),
                                                                              a(str("precedence"), arg)
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("output-list"), arg)
                                                                    ),
                                                                    b(str("adf"),
                                                                        c(
                                                                            a(str("rule"), arg),
                                                                            str("counter"),
                                                                            a(str("input-precedence"), arg),
                                                                            str("not-mandatory"),
                                                                            a(str("output-precedence"), arg)
                                                                        )
                                                                    ),
                                                                    a(str("group"), arg)
                                                                )
                                                            ),
                                                            b(str("ingress-queuing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            b(str("iq-policing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("input"), arg),
                                                                    a(str("output"), arg)
                                                                )
                                                            ),
                                                            b(str("sampling"),
                                                                c(
                                                                    str("input"),
                                                                    str("output")
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("bridge"),
                                                        c(
                                                            str("core-facing"),
                                                            b(str("filter"),
                                                                c(
                                                                    c(
                                                                      b(str("input"),
                                                                          sc(
                                                                              arg,
                                                                              a(str("shared-name"), arg),
                                                                              a(str("precedence"), arg)
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("input-list"), arg)
                                                                    ),
                                                                    a(str("input-chain"), arg),
                                                                    a(str("output-chain"), arg),
                                                                    c(
                                                                      b(str("output"),
                                                                          sc(
                                                                              arg,
                                                                              a(str("shared-name"), arg),
                                                                              a(str("precedence"), arg)
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("output-list"), arg)
                                                                    ),
                                                                    b(str("adf"),
                                                                        c(
                                                                            a(str("rule"), arg),
                                                                            str("counter"),
                                                                            a(str("input-precedence"), arg),
                                                                            str("not-mandatory"),
                                                                            a(str("output-precedence"), arg)
                                                                        )
                                                                    ),
                                                                    a(str("group"), arg)
                                                                )
                                                            ),
                                                            b(str("ingress-queuing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            b(str("iq-policing-filter"),
                                                                sc(
                                                                    arg
                                                                )
                                                            ).as(:oneline),
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("input"), arg),
                                                                    a(str("output"), arg)
                                                                )
                                                            ),
                                                            b(str("interface-mode"),
                                                              (str("access") | str("trunk"))
                                                            ),
                                                            str("vlan-auto-sense"),
                                                            b(str("bridge-domain-type"),
                                                              (str("svlan") | str("bvlan"))
                                                            ),
                                                            str("inter-switch-link"),
                                                            c(
                                                              a(str("vlan-id"), arg),
                                                              a(str("vlan-id-list"), arg),
                                                              a(str("inner-vlan-id-list"), arg)
                                                            ),
                                                            b(str("vlan-rewrite"),
                                                                c(
                                                                    b(a(str("translate"), arg),
                                                                        sc(
                                                                              arg
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            ),
                                                            c(
                                                              b(str("isid-list"),
                                                                (str("all-service-groups") | str("all"))
                                                              )
                                                            ),
                                                            b(str("storm-control"),
                                                                c(
                                                                    arg
                                                                )
                                                            ),
                                                            b(str("recovery-timeout"),
                                                                sc(
                                                                      arg
                                                                )
                                                            ).as(:oneline),
                                                            b(str("sampling"),
                                                                c(
                                                                    str("input"),
                                                                    str("output")
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("ethernet-switching"),
                                                      ethernet_switching_type
                                                    ),
                                                    b(str("fibre-channel"),
                                                      fibre_channel_type
                                                    ),
                                                    b(str("pppoe"),
                                                      pppoe_underlying_options_type
                                                    ),
                                                    b(str("any"),
                                                        c(
                                                            b(str("filter"),
                                                                c(
                                                                    a(str("input"), arg),
                                                                    a(str("group"), arg)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("service-domain"),
                                              (str("inside") | str("outside"))
                                            ),
                                            str("copy-tos-to-outer-ip-header"),
                                            str("copy-tos-to-outer-ip-header-transit"),
                                            str("force-control-packets-on-transit-path"),
                                            b(str("load-balancing-options"),
                                                c(
                                                    b(str("preferred-active"),
                                                      interface_device
                                                    ),
                                                    str("disable-hash"),
                                                    b(str("hash-keys"),
                                                        c(
                                                            b(str("ingress-key"),
                                                                  enum((str("source-ip") | str("destination-ip") | str("protocol") | str("iif")))
                                                            ),
                                                            b(str("egress-key"),
                                                                  enum((str("source-ip") | str("destination-ip") | str("protocol") | str("oif")))
                                                            ),
                                                            b(str("ipv6-source-prefix-length"),
                                                              (str("56") | str("64") | str("96") | str("128"))
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("mac"),
                                              mac_unicast
                                            ),
                                            b(str("virtual-gateway-v4-mac"),
                                              mac_unicast
                                            ),
                                            b(str("virtual-gateway-v6-mac"),
                                              mac_unicast
                                            ),
                                            b(str("forwarding-options"),
                                                c(
                                                    b(str("load-balance-stateful"),
                                                        c(
                                                            str("per-flow"),
                                                            a(str("rebalance"), arg),
                                                            b(str("load-type"),
                                                              (str("high") | str("medium") | str("low"))
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("etree-ac-role"),
                                              (str("root") | str("leaf"))
                                            )
                                        )
                                    ),
                                    b(str("no-partition"),
                                        sc(
                                            b(str("interface-type"),
                                              (str("e1") | str("t1") | str("at") | str("t3") | str("e3") | str("ct3") | str("so") | str("cau4"))
                                            )
                                        )
                                    ).as(:oneline),
                                    b(a(str("partition"), arg),
                                        sc(
                                            a(str("oc-slice"), arg),
                                            a(str("timeslots"), arg),
                                            b(str("interface-type"),
                                              (str("ds") | str("e1") | str("t1") | str("at") | str("ct1") | str("ce1") | str("t3") | str("ct3") | str("e3") | str("so") | str("coc1") | str("cau4") | str("dc") | str("bc"))
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("radius-options"),
                                      radius_options_vlan_type
                                    )
                                )
                            ),
                              interfaces_type
                        )
                    )
                )
            ),
            b(str("protocols"),
                c(
                    b(str("igmp"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("mtrace") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                        sc(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            a(str("query-interval"), arg),
                            a(str("query-response-interval"), arg),
                            a(str("query-last-member-interval"), arg),
                            a(str("robust-count"), arg),
                            a(str("maximum-transmit-rate"), arg),
                            str("accounting"),
                            a(str("interface"), arg | arg,
                                c(
                                      (str("disable")),
                                    a(str("version"), arg),
                                    b(str("static"),
                                        c(
                                            b(a(str("group"), arg),
                                                c(
                                                    b(str("group-increment"),
                                                      ipv4addr
                                                    ),
                                                    a(str("group-count"), arg),
                                                    str("exclude"),
                                                    b(a(str("source"), arg),
                                                        c(
                                                            b(str("source-increment"),
                                                              ipv4addr
                                                            ),
                                                            a(str("source-count"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    a(str("ssm-map"), arg),
                                    b(str("ssm-map-policy"),
                                      policy_algebra
                                    ),
                                    str("immediate-leave"),
                                    str("promiscuous-mode"),
                                    str("accounting"),
                                    str("no-accounting"),
                                    b(str("group-policy"),
                                      policy_algebra
                                    ),
                                    a(str("group-limit"), arg),
                                    a(str("group-threshold"), arg),
                                    a(str("log-interval"), arg),
                                    b(str("passive"),
                                        sc(
                                            str("allow-receive"),
                                            str("send-general-query"),
                                            str("send-group-query")
                                        )
                                    ).as(:oneline),
                                    b(str("oif-map"),
                                      policy_algebra
                                    ),
                                    str("distributed")
                                )
                            ),
                            b(str("amt"),
                                c(
                                    b(str("relay"),
                                        c(
                                            b(str("defaults"),
                                                c(
                                                    a(str("version"), arg),
                                                    a(str("ssm-map"), arg),
                                                    b(str("ssm-map-policy"),
                                                      policy_algebra
                                                    ),
                                                    str("accounting"),
                                                    str("no-accounting"),
                                                    b(str("group-policy"),
                                                      policy_algebra
                                                    ),
                                                    a(str("group-limit"), arg),
                                                    a(str("group-threshold"), arg),
                                                    a(str("log-interval"), arg),
                                                    a(str("robust-count"), arg),
                                                    a(str("query-interval"), arg),
                                                    a(str("query-response-interval"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("oam"),
                        c(
                            b(str("ethernet"),
                                c(
                                    b(str("link-fault-management"),
                                        c(
                                            str("hardware-assisted-keepalives"),
                                            b(str("traceoptions"),
                                                c(
                                                    str("no-remote-trace"),
                                                    b(str("file"),
                                                        sc(
                                                              arg,
                                                            a(str("size"), arg),
                                                            a(str("files"), arg),
                                                            str("world-readable"),
                                                            str("no-world-readable"),
                                                            b(str("match"),
                                                              regular_expression
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    a(str("flag"), enum(str("configuration") | str("routing-socket") | str("protocol") | str("action-profile") | str("all"))).as(:oneline)
                                                )
                                            ),
                                            b(a(str("action-profile"), arg),
                                                c(
                                                    b(str("event"),
                                                        c(
                                                            str("link-adjacency-loss"),
                                                            str("protocol-down"),
                                                            b(str("link-event-rate"),
                                                                c(
                                                                    a(str("symbol-period"), arg),
                                                                    a(str("frame-error"), arg),
                                                                    a(str("frame-period"), arg),
                                                                    a(str("frame-period-summary"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("action"),
                                                        c(
                                                            str("syslog"),
                                                            str("link-down"),
                                                            str("send-critical-event")
                                                        )
                                                    )
                                                )
                                            ),
                                            b(a(str("interface"), arg),
                                                c(
                                                    a(str("apply-action-profile"), arg),
                                                    a(str("pdu-interval"), arg),
                                                    str("loopback-tracking"),
                                                    str("detect-loc"),
                                                    b(str("link-discovery"),
                                                      (str("active") | str("passive"))
                                                    ),
                                                    a(str("pdu-threshold"), arg),
                                                    str("remote-loopback"),
                                                    b(str("negotiation-options"),
                                                        c(
                                                            str("no-allow-link-events"),
                                                            str("allow-remote-loopback")
                                                        )
                                                    ),
                                                    b(str("event-thresholds"),
                                                        c(
                                                            a(str("symbol-period"), arg),
                                                            a(str("frame-error"), arg),
                                                            a(str("frame-period"), arg),
                                                            a(str("frame-period-summary"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("connectivity-fault-management"),
                                        c(
                                            b(str("performance-monitoring"),
                                                c(
                                                    str("hardware-assisted-timestamping"),
                                                    str("delegate-server-processing"),
                                                    b(str("hardware-assisted-keepalives"),
                                                      (str("enable") | str("disable"))
                                                    ),
                                                    str("hardware-assisted-pm"),
                                                    str("enhanced-sla-iterator"),
                                                    b(str("measurement-interval"),
                                                      (str("2") | str("5") | str("15") | str("30") | str("60"))
                                                    ),
                                                    str("legacy-pm-display"),
                                                    b(a(str("sla-iterator-profiles"), arg),
                                                        c(
                                                            str("disable"),
                                                            b(str("measurement-type"),
                                                              (str("two-way-delay") | str("loss") | str("slm") | str("statistical-frame-loss"))
                                                            ),
                                                            a(str("flap-trap-monitor"), arg),
                                                            a(str("cycle-time"), arg),
                                                            a(str("iteration-period"), arg),
                                                            b(str("calculation-weight"),
                                                                c(
                                                                    a(str("delay"), arg),
                                                                    a(str("delay-variation"), arg)
                                                                )
                                                            ),
                                                            b(str("avg-flr-forward-threshold"),
                                                                ca(
                                                                    a(str("flap-trap-monitor"), arg)
                                                                )
                                                            ),
                                                            b(str("avg-flr-backward-threshold"),
                                                                ca(
                                                                    a(str("flap-trap-monitor"), arg)
                                                                )
                                                            ),
                                                            b(str("avg-fd-twoway-threshold"),
                                                                ca(
                                                                    a(str("flap-trap-monitor"), arg)
                                                                )
                                                            ),
                                                            b(str("avg-fdv-twoway-threshold"),
                                                                ca(
                                                                    a(str("flap-trap-monitor"), arg)
                                                                )
                                                            ),
                                                            b(str("measurement-interval"),
                                                              (str("2") | str("5") | str("15") | str("30") | str("60"))
                                                            ),
                                                            b(str("frame-delay"),
                                                                c(
                                                                    a(str("num-bins"), arg),
                                                                    b(str("two-way"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("forward"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("backward"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            b(str("frame-delay-range"),
                                                                c(
                                                                    a(str("num-bins"), arg),
                                                                    b(str("two-way"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("forward"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("backward"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            b(str("ifdv"),
                                                                c(
                                                                    a(str("num-bins"), arg),
                                                                    b(str("two-way"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("forward"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    ),
                                                                    b(str("backward"),
                                                                        c(
                                                                            a(str("lower-threshold-bin"), arg)
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            b(str("availability"),
                                                                c(
                                                                    a(str("num-consecutive-pdus"), arg),
                                                                    a(str("flr-threshold"), arg),
                                                                    a(str("num-consecutive-intervals"), arg),
                                                                    a(str("num-consecutive-highflr"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(a(str("interface"), arg),
                                                        sc(
                                                            str("enable-multiclass-loss-measurement"),
                                                            str("code-point-based-lm-accounting"),
                                                            str("priority-based-lm-accounting")
                                                        )
                                                    ).as(:oneline),
                                                    str("enable-multiclass-loss-measurement"),
                                                    str("code-point-based-lm-accounting"),
                                                    str("priority-based-lm-accounting"),
                                                    str("colorless-loss-measurement")
                                                )
                                            ),
                                            b(str("connection-protection"),
                                                c(
                                                    str("mark-connection-protection-tlv"),
                                                    str("uhp-label-lookup")
                                                )
                                            ),
                                            str("no-aggregate-delegate-processing"),
                                            str("enhanced-cfm-mode"),
                                            b(str("expected-defect"),
                                                c(
                                                    str("rx-enable"),
                                                    a(str("rx-max-duration"), arg),
                                                    str("tx-enable"),
                                                    a(str("tx-duration"), arg)
                                                )
                                            ),
                                            b(str("traceoptions"),
                                              cfm_traceoptions
                                            ),
                                            b(a(str("action-profile"), arg),
                                                c(
                                                    b(str("event"),
                                                        c(
                                                            b(str("interface-status-tlv"),
                                                              (str("down") | str("lower-layer-down"))
                                                            ),
                                                            b(str("port-status-tlv"),
                                                              (str("blocked"))
                                                            ),
                                                            str("adjacency-loss"),
                                                            str("rdi"),
                                                            b(str("connection-protection-tlv"),
                                                              (str("using-working-path") | str("using-protection-path"))
                                                            ),
                                                            b(str("server-mep-defects"),
                                                              (str("link-loss-defect") | str("l2circuit-defect") | str("l2vpn-defect"))
                                                            ),
                                                            b(str("ais-trigger-condition"),
                                                              (str("all-defects") | str("adjacency-loss") | str("cross-connect-ccm") | str("erroneous-ccm") | str("receive-ais"))
                                                            )
                                                        )
                                                    ),
                                                    b(str("action"),
                                                        c(
                                                            str("interface-down"),
                                                            str("revertive-interface-down"),
                                                            str("non-revertive-interface-down"),
                                                            str("propagate-remote-mac-flush"),
                                                            str("interface-group-down"),
                                                            b(str("log-and-generate-ais"),
                                                                c(
                                                                    a(str("level"), arg),
                                                                    b(str("interval"),
                                                                      (str("1s") | str("1m"))
                                                                    ),
                                                                    a(str("priority"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("clear-action"),
                                                        c(
                                                            b(str("interface-down"),
                                                                sc(
                                                                    str("peer-interface")
                                                                )
                                                            ).as(:oneline),
                                                            str("propagate-remote-mac-flush")
                                                        )
                                                    ),
                                                    b(str("default-actions"),
                                                        c(
                                                            str("interface-down")
                                                        )
                                                    )
                                                )
                                            ),
                                            b(a(str("server-mep"), arg),
                                                c(
                                                    b(str("protocol"),
                                                        c(
                                                            c(
                                                              b(str("l2circuit"),
                                                                  sc(
                                                                      b(str("interface"),
                                                                          sc(
                                                                                interface_name
                                                                          )
                                                                      ).as(:oneline)
                                                                  )
                                                              ).as(:oneline),
                                                              b(str("l2vpn"),
                                                                  sc(
                                                                      b(str("interface"),
                                                                          sc(
                                                                                interface_name
                                                                          )
                                                                      ).as(:oneline)
                                                                  )
                                                              ).as(:oneline),
                                                              b(str("ethernet"),
                                                                  sc(
                                                                      b(str("interface"),
                                                                          sc(
                                                                                interface_device
                                                                          )
                                                                      ).as(:oneline)
                                                                  )
                                                              ).as(:oneline)
                                                            )
                                                        )
                                                    ),
                                                    b(str("action-profile"),
                                                        c(
                                                            arg
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("policer"),
                                                c(
                                                    a(str("continuity-check"), arg),
                                                    a(str("other"), arg),
                                                    a(str("all"), arg)
                                                )
                                            ),
                                            b(str("linktrace"),
                                                c(
                                                    a(str("path-database-size"), arg),
                                                    b(str("age"),
                                                      (str("10s") | str("30s") | str("1m") | str("10m") | str("30m"))
                                                    )
                                                )
                                            ),
                                            a(str("maintenance-domain"), str("default-0") | str("default-1") | str("default-2") | str("default-3") | str("default-4") | str("default-5") | str("default-6") | str("default-7") | arg,
                                                c(
                                                    b(a(str("bridge-domain"), arg),
                                                        sc(
                                                            a(str("vlan-id"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    a(str("vlan"), arg).as(:oneline),
                                                    b(a(str("virtual-switch"), arg),
                                                        c(
                                                            b(a(str("bridge-domain"), arg),
                                                                sc(
                                                                    a(str("vlan-id"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    a(str("instance"), arg).as(:oneline),
                                                    a(str("interface"), arg).as(:oneline),
                                                    a(str("level"), arg),
                                                    b(str("name-format"),
                                                      (str("none") | str("dns") | str("mac+2oct") | str("character-string"))
                                                    ),
                                                    b(str("mip-half-function"),
                                                      (str("none") | str("default") | str("explicit"))
                                                    ),
                                                    b(a(str("maintenance-association"), arg),
                                                        c(
                                                            str("debug-session"),
                                                            b(str("short-name-format"),
                                                              (str("2octet") | str("rfc-2685-vpn-id") | str("vlan") | str("character-string") | str("icc"))
                                                            ),
                                                            b(str("protect-maintenance-association"),
                                                                sc(
                                                                      arg,
                                                                    a(str("aps-profile"), arg),
                                                                    str("detect-path-type")
                                                                )
                                                            ).as(:oneline),
                                                            b(str("primary-vid"),
                                                              (str("none") | arg)
                                                            ),
                                                            b(str("continuity-check"),
                                                                c(
                                                                    b(str("interval"),
                                                                      (str("10ms") | str("100ms") | str("1s") | str("10s") | str("1m") | str("10m") | str("3.3ms"))
                                                                    ),
                                                                    a(str("loss-threshold"), arg),
                                                                    a(str("hold-interval"), arg),
                                                                    str("port-status-tlv"),
                                                                    str("interface-status-tlv"),
                                                                    str("connection-protection-tlv"),
                                                                    str("convey-loss-threshold"),
                                                                    str("interface-status-send-rdi"),
                                                                    b(str("sendid-tlv"),
                                                                        c(
                                                                            str("send-chassis-tlv")
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            b(str("mip-half-function"),
                                                              (str("none") | str("default") | str("explicit") | str("defer"))
                                                            ),
                                                            b(a(str("mep"), arg),
                                                                c(
                                                                    b(str("interface"),
                                                                        sc(
                                                                              interface_unit,
                                                                            a(str("vlan"), arg),
                                                                            c(
                                                                              str("working"),
                                                                              str("protect")
                                                                            )
                                                                        )
                                                                    ).as(:oneline),
                                                                    b(str("direction"),
                                                                      (str("up") | str("down"))
                                                                    ),
                                                                    a(str("priority"), arg),
                                                                    str("auto-discovery"),
                                                                    a(str("action-profile"), arg),
                                                                    b(a(str("remote-mep"), arg),
                                                                        c(
                                                                            a(str("action-profile"), arg),
                                                                            b(str("interface-group"),
                                                                                c(
                                                                                      interface_device,
                                                                                    a(str("unit-list"), arg)
                                                                                )
                                                                            ),
                                                                            b(a(str("sla-iterator-profile"), arg),
                                                                                c(
                                                                                    a(str("iteration-count"), arg),
                                                                                    a(str("priority"), arg),
                                                                                    a(str("data-tlv-size"), arg)
                                                                                )
                                                                            ),
                                                                            str("detect-loc")
                                                                        )
                                                                    ),
                                                                    b(str("lowest-priority-defect"),
                                                                      (str("all-defects") | str("mac-rem-err-xcon") | str("rem-err-xcon") | str("err-xcon") | str("xcon") | str("no-defect"))
                                                                    )
                                                                )
                                                            ),
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("continuity-check"), arg),
                                                                    a(str("other"), arg),
                                                                    a(str("all"), arg)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("sendid-tlv"),
                                                c(
                                                    str("send-chassis-tlv")
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("evcs"), arg),
                                        c(
                                            b(str("evc-protocol"),
                                                sc(
                                                    c(
                                                      b(str("cfm"),
                                                          sc(
                                                              a(str("maintenance-domain"), arg),
                                                              a(str("maintenance-association"), arg),
                                                              a(str("mep"), arg),
                                                              b(str("faults"),
                                                                  c(
                                                                      str("rdi")
                                                                  )
                                                              )
                                                          )
                                                      ).as(:oneline),
                                                      b(str("vpls"),
                                                          sc(
                                                              a(str("routing-instance"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("l2circuit"),
                                                          c(
                                                              b(str("interface"),
                                                                  sc(
                                                                        interface_name
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ),
                                                      b(str("l2vpn"),
                                                          c(
                                                              b(str("interface"),
                                                                  sc(
                                                                        interface_name
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      )
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("remote-uni-count"), arg),
                                            a(str("async-status-msg-transmit-interval"), arg),
                                            str("multipoint-to-multipoint")
                                        )
                                    ),
                                    b(str("lmi"),
                                        c(
                                            b(str("traceoptions"),
                                                c(
                                                    str("no-remote-trace"),
                                                    b(str("file"),
                                                        sc(
                                                              arg,
                                                            a(str("size"), arg),
                                                            a(str("files"), arg),
                                                            str("world-readable"),
                                                            str("no-world-readable"),
                                                            b(str("match"),
                                                              regular_expression
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    a(str("flag"), enum(str("configuration") | str("routing-socket") | str("protocol") | str("init") | str("error") | str("packet") | str("all"))).as(:oneline)
                                                )
                                            ),
                                            a(str("status-counter"), arg),
                                            a(str("polling-verification-timer"), arg),
                                            b(a(str("interface"), arg),
                                                c(
                                                    a(str("uni-id"), arg),
                                                    a(str("status-counter"), arg),
                                                    a(str("polling-verification-timer"), arg),
                                                    b(str("evc-map-type"),
                                                      (str("all-to-one-bundling") | str("service-multiplexing") | str("bundling"))
                                                    ),
                                                    b(a(str("evc"), arg),
                                                        c(
                                                            str("default-evc"),
                                                            a(str("vlan-list"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("fnp"),
                                        c(
                                            b(str("traceoptions"),
                                                c(
                                                    b(str("file"),
                                                        sc(
                                                              arg,
                                                            str("replace"),
                                                            a(str("size"), arg),
                                                            a(str("files"), arg),
                                                            str("no-stamp"),
                                                            str("world-readable"),
                                                            str("no-world-readable")
                                                        )
                                                    ).as(:oneline),
                                                    a(str("flag"), enum(str("events") | str("pdu") | str("timers") | str("error") | str("all"))).as(:oneline)
                                                )
                                            ),
                                            b(str("interval"),
                                              (str("100ms") | str("1s") | str("10s") | str("1m") | str("10m"))
                                            ),
                                            a(str("loss-threshold"), arg),
                                            b(a(str("interface"), arg),
                                                c(
                                                    a(str("domain-id"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("gre-tunnel"),
                                c(
                                    b(str("traceoptions"),
                                        c(
                                            str("no-remote-trace"),
                                            b(str("file"),
                                                sc(
                                                      arg,
                                                    a(str("size"), arg),
                                                    a(str("files"), arg),
                                                    str("world-readable"),
                                                    str("no-world-readable"),
                                                    b(str("match"),
                                                      regular_expression
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("flag"), enum(str("configuration") | str("routing-socket") | str("protocol") | str("snmp") | str("all"))).as(:oneline)
                                        )
                                    ),
                                    b(a(str("interface"), arg),
                                        c(
                                            a(str("keepalive-time"), arg),
                                            a(str("hold-time"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("mld"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("mtrace") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                        sc(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            a(str("query-interval"), arg),
                            a(str("query-response-interval"), arg),
                            a(str("query-last-member-interval"), arg),
                            a(str("robust-count"), arg),
                            a(str("maximum-transmit-rate"), arg),
                            str("accounting"),
                            a(str("interface"), arg | arg,
                                c(
                                      (str("disable")),
                                    a(str("version"), arg),
                                    b(str("static"),
                                        c(
                                            b(a(str("group"), arg),
                                                c(
                                                    b(str("group-increment"),
                                                      ipv6addr
                                                    ),
                                                    a(str("group-count"), arg),
                                                    str("exclude"),
                                                    b(a(str("source"), arg),
                                                        c(
                                                            b(str("source-increment"),
                                                              ipv6addr
                                                            ),
                                                            a(str("source-count"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    a(str("ssm-map"), arg),
                                    b(str("ssm-map-policy"),
                                      policy_algebra
                                    ),
                                    str("immediate-leave"),
                                    b(str("group-policy"),
                                      policy_algebra
                                    ),
                                    a(str("group-limit"), arg),
                                    a(str("group-threshold"), arg),
                                    a(str("log-interval"), arg),
                                    str("accounting"),
                                    str("no-accounting"),
                                    b(str("passive"),
                                        sc(
                                            str("allow-receive"),
                                            str("send-general-query"),
                                            str("send-group-query")
                                        )
                                    ).as(:oneline),
                                    b(str("oif-map"),
                                      policy_algebra
                                    ),
                                    str("distributed")
                                )
                            )
                        )
                    ),
                    b(str("pim"),
                      juniper_protocols_pim
                    ),
                    b(str("router-advertisement"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"))).as(:oneline)
                                )
                            ),
                            a(str("interface"), arg | arg,
                                c(
                                    b(str("preference"),
                                      (str("medium") | str("high") | str("low"))
                                    ),
                                    a(str("max-advertisement-interval"), arg),
                                    a(str("min-advertisement-interval"), arg),
                                    str("managed-configuration"),
                                    str("no-managed-configuration"),
                                    str("other-stateful-configuration"),
                                    str("no-other-stateful-configuration"),
                                    str("link-mtu"),
                                    str("no-link-mtu"),
                                    str("solicit-router-advertisement-unicast"),
                                    a(str("reachable-time"), arg),
                                    a(str("retransmit-timer"), arg),
                                    str("virtual-router-only"),
                                    a(str("current-hop-limit"), arg),
                                    a(str("default-lifetime"), arg),
                                    a(str("dns-server-address"), arg | arg,
                                        c(
                                            a(str("lifetime"), arg)
                                        )
                                    ),
                                    b(a(str("prefix"), arg),
                                        c(
                                            a(str("valid-lifetime"), arg),
                                            str("on-link"),
                                            str("no-on-link"),
                                            a(str("preferred-lifetime"), arg),
                                            str("autonomous"),
                                            str("no-autonomous")
                                        )
                                    )
                                )
                            ),
                            b(str("ra-secure"),
                                c(
                                    a(str("accept-current-hop-limit-min"), arg),
                                    a(str("accept-current-hop-limit-max"), arg),
                                    a(str("accept-reachable-time-min"), arg),
                                    a(str("accept-reachable-time-max"), arg),
                                    a(str("accept-retransmit-time-min"), arg),
                                    a(str("accept-retransmit-time-max"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("class-of-service"),
              juniper_class_of_service_options
            ),
            b(str("routing-options"),
                c(
                    b(a(str("rib"), arg),
                        c(
                            b(str("static"),
                                c(
                                    b(a(str("route"), arg),
                                        c(
                                            c(
                                              b(str("next-hop"),
                                                ipaddr_or_interface
                                              ),
                                              str("reject"),
                                              str("discard"),
                                              str("receive"),
                                              a(str("next-table"), arg)
                                            ),
                                            b(str("qualified-next-hop"),
                                              qualified_nh_obj
                                            ),
                                            a(str("backup-pe-group"), arg),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    b(str("version"),
                                                      (str("0") | str("1") | str("automatic"))
                                                    ),
                                                    a(str("minimum-interval"), arg),
                                                    a(str("minimum-transmit-interval"), arg),
                                                    a(str("minimum-receive-interval"), arg),
                                                    a(str("multiplier"), arg),
                                                    c(
                                                      str("no-adaptation")
                                                    ),
                                                    b(str("transmit-interval"),
                                                        c(
                                                            a(str("minimum-interval"), arg),
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("detection-time"),
                                                        c(
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("authentication"),
                                                        c(
                                                            a(str("key-chain"), arg),
                                                            b(str("algorithm"),
                                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                            ),
                                                            str("loose-check")
                                                        )
                                                    ),
                                                    b(str("neighbor"),
                                                      ipaddr
                                                    ),
                                                    b(str("local-address"),
                                                      ipaddr
                                                    ),
                                                    a(str("holddown-interval"), arg),
                                                    a(str("minimum-receive-ttl"), arg)
                                                )
                                            ),
                                            str("retain"),
                                            str("no-retain"),
                                            str("install"),
                                            str("no-install"),
                                            str("readvertise"),
                                            str("no-readvertise"),
                                            str("resolve"),
                                            str("no-resolve"),
                                            str("longest-match"),
                                            str("no-longest-match"),
                                            c(
                                              str("active"),
                                              str("passive")
                                            ),
                                            b(str("metric"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric3"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric4"),
                                              rib_static_metric_type
                                            ),
                                            b(str("tag"),
                                              rib_static_metric_type
                                            ),
                                            b(str("tag2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("preference"),
                                              rib_static_metric_type
                                            ),
                                            b(str("preference2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("color"),
                                              rib_static_metric_type
                                            ),
                                            b(str("color2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("community"),
                                              community
                                            ),
                                            b(str("as-path"),
                                              c(
                                                a(str("path"), quote | arg),
                                                    b(str("origin"),
                                                      (str("igp") | str("egp") | str("incomplete"))
                                                    ),
                                                    str("atomic-aggregate"),
                                                    b(str("aggregator"),
                                                        ca(
                                                              ipv4addr
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("lsp-next-hop"),
                                              lsp_nh_obj
                                            ),
                                            b(str("static-lsp-next-hop"),
                                              lsp_nh_obj
                                            ),
                                            b(str("p2mp-lsp-next-hop"),
                                              lsp_nh_obj
                                            ),
                                            b(str("p2mp-ldp-next-hop"),
                                              p2mp_ldp_lsp_nh_obj
                                            )
                                        )
                                    ),
                                    b(a(str("iso-route"), arg),
                                        c(
                                            c(
                                              b(str("next-hop"),
                                                ipaddr_or_interface
                                              ),
                                              str("reject"),
                                              str("discard"),
                                              str("receive"),
                                              a(str("next-table"), arg)
                                            ),
                                            b(str("qualified-next-hop"),
                                              qualified_nh_obj
                                            ),
                                            a(str("backup-pe-group"), arg),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    b(str("version"),
                                                      (str("0") | str("1") | str("automatic"))
                                                    ),
                                                    a(str("minimum-interval"), arg),
                                                    a(str("minimum-transmit-interval"), arg),
                                                    a(str("minimum-receive-interval"), arg),
                                                    a(str("multiplier"), arg),
                                                    c(
                                                      str("no-adaptation")
                                                    ),
                                                    b(str("transmit-interval"),
                                                        c(
                                                            a(str("minimum-interval"), arg),
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("detection-time"),
                                                        c(
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("authentication"),
                                                        c(
                                                            a(str("key-chain"), arg),
                                                            b(str("algorithm"),
                                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                            ),
                                                            str("loose-check")
                                                        )
                                                    ),
                                                    b(str("neighbor"),
                                                      ipaddr
                                                    ),
                                                    b(str("local-address"),
                                                      ipaddr
                                                    ),
                                                    a(str("holddown-interval"), arg),
                                                    a(str("minimum-receive-ttl"), arg)
                                                )
                                            ),
                                            str("retain"),
                                            str("no-retain"),
                                            str("install"),
                                            str("no-install"),
                                            str("readvertise"),
                                            str("no-readvertise"),
                                            str("resolve"),
                                            str("no-resolve"),
                                            str("longest-match"),
                                            str("no-longest-match"),
                                            c(
                                              str("active"),
                                              str("passive")
                                            ),
                                            b(str("metric"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric3"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric4"),
                                              rib_static_metric_type
                                            ),
                                            b(str("tag"),
                                              rib_static_metric_type
                                            ),
                                            b(str("tag2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("preference"),
                                              rib_static_metric_type
                                            ),
                                            b(str("preference2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("color"),
                                              rib_static_metric_type
                                            ),
                                            b(str("color2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("community"),
                                              community
                                            ),
                                            b(str("as-path"),
                                              c(
                                                a(str("path"), quote | arg),
                                                    b(str("origin"),
                                                      (str("igp") | str("egp") | str("incomplete"))
                                                    ),
                                                    str("atomic-aggregate"),
                                                    b(str("aggregator"),
                                                        ca(
                                                              ipv4addr
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("lsp-next-hop"),
                                              lsp_nh_obj
                                            ),
                                            b(str("static-lsp-next-hop"),
                                              lsp_nh_obj
                                            ),
                                            b(str("p2mp-lsp-next-hop"),
                                              lsp_nh_obj
                                            ),
                                            b(str("p2mp-ldp-next-hop"),
                                              p2mp_ldp_lsp_nh_obj
                                            )
                                        )
                                    ),
                                    a(str("rib-group"), arg),
                                    b(str("defaults"),
                                        c(
                                            str("retain"),
                                            str("no-retain"),
                                            str("install"),
                                            str("no-install"),
                                            str("readvertise"),
                                            str("no-readvertise"),
                                            str("resolve"),
                                            str("no-resolve"),
                                            str("longest-match"),
                                            str("no-longest-match"),
                                            c(
                                              str("active"),
                                              str("passive")
                                            ),
                                            b(str("metric"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric3"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric4"),
                                              rib_static_metric_type
                                            ),
                                            b(str("tag"),
                                              rib_static_metric_type
                                            ),
                                            b(str("tag2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("preference"),
                                              rib_static_metric_type
                                            ),
                                            b(str("preference2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("color"),
                                              rib_static_metric_type
                                            ),
                                            b(str("color2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("community"),
                                              community
                                            ),
                                            b(str("as-path"),
                                              c(
                                                a(str("path"), quote | arg),
                                                    b(str("origin"),
                                                      (str("igp") | str("egp") | str("incomplete"))
                                                    ),
                                                    str("atomic-aggregate"),
                                                    b(str("aggregator"),
                                                        ca(
                                                              ipv4addr
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("static-route"),
                                        sc(
                                            b(str("bfd-admin-down"),
                                              (str("active") | str("passive"))
                                            )
                                        )
                                    ).as(:oneline),
                                    b(a(str("route-target-filter"), arg),
                                        c(
                                            b(str("neighbor"),
                                              ipaddr
                                            ),
                                            a(str("group"), arg),
                                            str("local")
                                        )
                                    )
                                )
                            ),
                            b(str("martians"),
                              martian_type
                            ),
                            b(str("aggregate"),
                              rib_aggregate_type
                            ),
                            b(str("generate"),
                              rib_aggregate_type
                            ),
                            c(
                              b(str("maximum-routes"),
                                  sc(
                                        arg,
                                      c(
                                        a(str("threshold"), arg),
                                        str("log-only")
                                      ),
                                      a(str("log-interval"), arg)
                                  )
                              ).as(:oneline),
                              b(str("maximum-paths"),
                                  sc(
                                        arg,
                                      c(
                                        a(str("threshold"), arg),
                                        str("log-only")
                                      ),
                                      a(str("log-interval"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            b(str("maximum-prefixes"),
                                sc(
                                      arg,
                                    c(
                                      a(str("threshold"), arg),
                                      str("log-only")
                                    ),
                                    a(str("log-interval"), arg)
                                )
                            ).as(:oneline),
                            b(str("multipath"),
                                c(
                                    b(str("vpn-unequal-cost"),
                                        sc(
                                            str("equal-external-internal")
                                        )
                                    ).as(:oneline),
                                    str("as-path-compare"),
                                    str("preserve-nexthop-hierarchy")
                                )
                            ),
                            b(str("policy-multipath"),
                                c(
                                    b(str("policy"),
                                      policy_algebra
                                    ),
                                    b(str("traceoptions"),
                                        c(
                                            b(str("file"),
                                                sc(
                                                      arg,
                                                    str("replace"),
                                                    a(str("size"), arg),
                                                    a(str("files"), arg),
                                                    str("no-stamp"),
                                                    str("world-readable"),
                                                    str("no-world-readable")
                                                )
                                            ).as(:oneline),
                                            a(str("flag"), enum(str("route")),
                                                sc(
                                                    str("send"),
                                                    str("receive"),
                                                    str("detail"),
                                                    str("disable")
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("protect"),
                                sc(
                                    str("core")
                                )
                            ).as(:oneline),
                            b(str("access"),
                                c(
                                    b(a(str("route"), arg),
                                        c(
                                            b(str("next-hop"),
                                              ipaddr_or_interface
                                            ),
                                            b(str("qualified-next-hop"),
                                              qualified_nh_obj
                                            ),
                                            a(str("metric"), arg),
                                            a(str("preference"), arg),
                                            a(str("tag"), arg),
                                            a(str("tag2"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("access-internal"),
                                c(
                                    b(a(str("route"), arg),
                                        c(
                                            b(str("next-hop"),
                                              ipaddr_or_interface
                                            ),
                                            b(str("qualified-next-hop"),
                                              qualified_nh_obj
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("bgp-static"),
                                c(
                                    b(a(str("route"), arg),
                                        c(
                                            b(str("metric"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric3"),
                                              rib_static_metric_type
                                            ),
                                            b(str("metric4"),
                                              rib_static_metric_type
                                            ),
                                            b(str("tag"),
                                              rib_static_metric_type
                                            ),
                                            b(str("tag2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("preference"),
                                              rib_static_metric_type
                                            ),
                                            b(str("preference2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("color"),
                                              rib_static_metric_type
                                            ),
                                            b(str("color2"),
                                              rib_static_metric_type
                                            ),
                                            b(str("community"),
                                              community
                                            ),
                                            b(str("as-path"),
                                              c(
                                                a(str("path"), quote | arg),
                                                    b(str("origin"),
                                                      (str("igp") | str("egp") | str("incomplete"))
                                                    ),
                                                    str("atomic-aggregate"),
                                                    b(str("aggregator"),
                                                        ca(
                                                              ipv4addr
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("flow"),
                                c(
                                    b(str("validation"),
                                      flow_validation
                                    ),
                                    b(str("route"),
                                      flow_route_inet6
                                    ),
                                    b(str("interface-group"),
                                      flow_interface_group
                                    ),
                                    str("discard-action-for-unresolved-redir-addr")
                                )
                            ),
                            b(str("label"),
                                c(
                                    b(str("allocation"),
                                      policy_algebra
                                    ),
                                    b(str("substitution"),
                                      policy_algebra
                                    )
                                )
                            )
                        )
                    ),
                    b(str("access"),
                        c(
                            b(a(str("route"), arg),
                                c(
                                    b(str("next-hop"),
                                      ipaddr_or_interface
                                    ),
                                    b(str("qualified-next-hop"),
                                      qualified_nh_obj
                                    ),
                                    a(str("metric"), arg),
                                    a(str("preference"), arg),
                                    a(str("tag"), arg),
                                    a(str("tag2"), arg)
                                )
                            )
                        )
                    ),
                    b(str("access-internal"),
                        c(
                            b(a(str("route"), arg),
                                c(
                                    b(str("next-hop"),
                                      ipaddr_or_interface
                                    ),
                                    b(str("qualified-next-hop"),
                                      qualified_nh_obj
                                    )
                                )
                            )
                        )
                    ),
                    b(str("multicast"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("parse") | str("config-internal") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                        sc(
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            a(str("rpf"), arg),
                            b(a(str("scope"), arg),
                                c(
                                    b(str("prefix"),
                                      ipprefix
                                    ),
                                    b(str("interface"),
                                      interface_name
                                    )
                                )
                            ),
                            b(str("scope-policy"),
                              policy_algebra
                            ),
                            b(a(str("flow-map"), arg),
                                c(
                                    b(str("policy"),
                                      policy_algebra
                                    ),
                                    b(str("bandwidth"),
                                        sc(
                                            arg,
                                            str("adaptive")
                                        )
                                    ).as(:oneline),
                                    b(str("redundant-sources"),
                                      ipaddr
                                    ),
                                    b(str("forwarding-cache"),
                                        c(
                                            b(str("timeout"),
                                                sc(
                                                    ca(
                                                      b(str("never"),
                                                          c(
                                                              str("non-discard-entry-only")
                                                          )
                                                      )
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("resolve-filter"),
                              policy_algebra
                            ),
                            b(str("ssm-groups"),
                              ipprefix
                            ),
                            str("asm-override-ssm"),
                            b(str("rpf-check-policy"),
                              policy_algebra
                            ),
                            b(str("pim-to-igmp-proxy"),
                                c(
                                    b(str("upstream-interface"),
                                      interface_name
                                    )
                                )
                            ),
                            b(str("pim-to-mld-proxy"),
                                c(
                                    b(str("upstream-interface"),
                                      interface_name
                                    )
                                )
                            ),
                            b(str("forwarding-cache"),
                                c(
                                    str("allow-maximum"),
                                    a(str("family"), enum(str("inet6") | str("inet")),
                                        c(
                                            b(str("threshold"),
                                                c(
                                                    a(str("suppress"), arg),
                                                    a(str("reuse"), arg),
                                                    a(str("mvpn-rpt-suppress"), arg),
                                                    a(str("mvpn-rpt-reuse"), arg),
                                                    a(str("log-warning"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("threshold"),
                                        c(
                                            a(str("suppress"), arg),
                                            a(str("reuse"), arg),
                                            a(str("mvpn-rpt-suppress"), arg),
                                            a(str("mvpn-rpt-reuse"), arg),
                                            a(str("log-warning"), arg)
                                        )
                                    ),
                                    a(str("timeout"), arg)
                                )
                            ),
                            b(str("interface"),
                              multicast_interface_options_type
                            ),
                            b(a(str("ssm-map"), arg),
                                c(
                                    b(str("policy"),
                                      policy_algebra
                                    ),
                                    b(str("source"),
                                      ipaddr
                                    )
                                )
                            ),
                            b(str("stream-protection"),
                                c(
                                    str("mofrr-primary-path-selection-by-routing"),
                                    str("mofrr-disjoint-upstream-only"),
                                    str("mofrr-no-backup-join"),
                                    str("mofrr-asm-starg"),
                                    b(str("policy"),
                                      policy_algebra
                                    )
                                )
                            ),
                            b(a(str("backup-pe-group"), arg),
                                c(
                                    b(str("backups"),
                                      ipaddr
                                    ),
                                    b(str("local-address"),
                                      ipaddr
                                    )
                                )
                            ),
                            str("omit-wildcard-address"),
                            b(str("local-address"),
                              ipv4addr
                            )
                        )
                    )
                )
            ),
            b(str("firewall"),
                c(
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("dialer-filter"),
                                      inet_dialer_filter
                                    ),
                                    b(str("prefix-action"),
                                      prefix_action
                                    ),
                                    b(str("filter"),
                                      inet_filter
                                    ),
                                    b(str("template"),
                                      inet_template
                                    ),
                                    b(str("simple-filter"),
                                      inet_simple_filter
                                    ),
                                    b(str("service-filter"),
                                      inet_service_filter
                                    ),
                                    b(str("fast-update-filter"),
                                      inet_fuf
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("dialer-filter"),
                                      inet6_dialer_filter
                                    ),
                                    b(str("filter"),
                                      inet6_filter
                                    ),
                                    b(str("service-filter"),
                                      inet6_service_filter
                                    ),
                                    b(str("fast-update-filter"),
                                      inet6_fuf
                                    ),
                                    b(str("template"),
                                      inet6_template
                                    )
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    b(str("dialer-filter"),
                                      mpls_dialer_filter
                                    ),
                                    b(str("filter"),
                                      mpls_filter
                                    ),
                                    b(str("template"),
                                      mpls_template
                                    )
                                )
                            ),
                            b(str("vpls"),
                                c(
                                    b(str("filter"),
                                      vpls_filter
                                    )
                                )
                            ),
                            b(str("evpn"),
                                c(
                                    b(str("filter"),
                                      vpls_filter
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                    b(str("filter"),
                                      bridge_filter
                                    )
                                )
                            ),
                            b(str("ccc"),
                                c(
                                    b(str("filter"),
                                      ccc_filter
                                    )
                                )
                            ),
                            b(str("any"),
                                c(
                                    b(str("filter"),
                                      any_filter
                                    ),
                                    b(str("template"),
                                      any_template
                                    )
                                )
                            ),
                            b(str("ethernet-switching"),
                                c(
                                    b(str("filter"),
                                      es_filter
                                    ),
                                    b(str("template"),
                                      es_template
                                    )
                                )
                            )
                        )
                    ),
                    b(str("policer"),
                      firewall_policer
                    ),
                    b(str("flexible-match"),
                      firewall_flexible_match
                    ),
                    b(str("tunnel-end-point"),
                      tunnel_end_point
                    ),
                    b(str("hierarchical-policer"),
                      firewall_hierpolicer
                    ),
                    b(str("interface-set"),
                      interface_set_type
                    ),
                    b(str("load-balance-group"),
                      firewall_load_balance_group
                    ),
                    b(str("atm-policer"),
                      atm_policer_type
                    ),
                    b(str("three-color-policer"),
                      three_color_policer_type
                    ),
                    b(str("filter"),
                      inet_filter
                    )
                )
            ),
            b(str("services"),
                c(
                    b(str("aacl"),
                        c(
                            b(str("rule"),
                              aacl_rule_object
                            ),
                            b(a(str("rule-set"), arg),
                                c(
                                    a(str("rule"), arg)
                                )
                            ),
                            b(a(str("aacl-dyn-rule-set"), arg),
                                c(
                                    a(str("rule"), arg)
                                )
                            )
                        )
                    ),
                    b(str("captive-portal-content-delivery"),
                        c(
                            a(str("auto-deactivate"), arg),
                            b(str("rule"),
                              cpcd_rule_object_type
                            ),
                            b(a(str("rule-set"), arg),
                                c(
                                    a(str("rule"), arg)
                                )
                            ),
                            b(a(str("profile"), arg),
                                c(
                                    c(
                                      str("dynamic"),
                                      a(str("cpcd-rules"), arg),
                                      a(str("cpcd-rule-sets"), arg)
                                    ),
                                    b(str("ipda-rewrite-options"),
                                        c(
                                            b(str("destination-address"),
                                              ipaddr
                                            ),
                                            a(str("destination-port"), arg)
                                        )
                                    ),
                                    b(str("http-redirect-options"),
                                        c(
                                            arg
                                        )
                                    ),
                                    b(str("auto-deactivate"),
                                      (str("never") | str("initial-get"))
                                    )
                                )
                            ),
                            b(str("traceoptions"),
                              cpcd_trace_options_type
                            )
                        )
                    )
                )
            ),
            b(str("profile-variable-set"),
              juniper_dynamic_profile_varset_object
            ),
            b(str("policy-options"),
                c(
                    b(a(str("prefix-list"), arg),
                        c(
                              a(str("apply-path"), quote | arg),
                              prefix_list_items
                        )
                    )
                )
            ),
            b(str("extensible-subscriber-services"),
                c(
                    a(str("vsas"), arg)
                )
            ),
            b(str("access-cac"),
                c(
                    b(str("interface"),
                      access_cac_interface_options
                    )
                )
            ),
            b(str("profile-type"),
                c(
                    str("remote-device-service")
                )
            )
        )
      )
    end

    rule(:access_cac_interface_options) do
      b(arg.as(:arg),
        c(
            b(str("multicast-video-bandwidth"),
                sc(
                    arg
                )
            ).as(:oneline),
            b(str("video-bandwidth"),
                sc(
                    arg
                )
            ).as(:oneline),
            c(
              str("no-qos-adjust"),
              b(str("qos-adjust-hierarchical"),
                  c(
                      str("interface-set")
                  )
              )
            ),
            b(a(str("multicast-video-policy"), arg),
                c(
                    b(str("family"),
                        c(
                            c(
                              b(str("inet"),
                                  c(
                                      b(str("source"),
                                        ipv4addr
                                      ),
                                      b(str("group"),
                                        ipv4addr
                                      )
                                  )
                              ),
                              b(str("inet6"),
                                  c(
                                      b(str("source"),
                                        ipv6addr
                                      ),
                                      b(str("group"),
                                        ipv6addr
                                      )
                                  )
                              )
                            )
                        )
                    ),
                    b(str("bandwidth"),
                        c(
                            arg
                        )
                    ),
                    str("adaptive")
                )
            )
        )
      )
    end

    rule(:base_default_variable_object) do
      b((str("igmp-enable") | str("igmp-access-group-name") | str("igmp-access-source-group-name") | str("igmp-version") | str("igmp-immediate-leave") | str("mld-access-group-name") | str("mld-access-source-group-name") | str("mld-immediate-leave") | str("input-filter") | str("output-filter") | str("input-interface-filter") | str("output-interface-filter") | str("input-ipv6-filter") | str("output-ipv6-filter") | str("adf-rule-v4") | str("adf-rule-v6") | str("cos-scheduler-map") | str("cos-shaping-rate") | str("cos-guaranteed-rate") | str("cos-delay-buffer-rate") | str("cos-traffic-control-profile") | str("cos-shaping-mode") | str("cos-byte-adjust") | str("cos-scheduler") | str("cos-scheduler-pri") | str("cos-scheduler-dropfile-low") | str("cos-scheduler-dropfile-medium-low") | str("cos-scheduler-dropfile-medium-high") | str("cos-scheduler-dropfile-high") | str("cos-scheduler-dropfile-any") | str("cos-scheduler-excess-rate") | str("cos-scheduler-explicit-congestion-notification") | str("cos-scheduler-excess-priority") | str("cos-adjust-minimum") | str("cos-excess-rate-high") | str("cos-excess-rate-low") | str("cos-shaping-rate-burst") | str("cos-byte-adjust-frame") | str("cos-byte-adjust-cell") | str("cos-shaping-rate-priority-high") | str("cos-shaping-rate-priority-high-burst") | str("cos-shaping-rate-priority-medium") | str("cos-shaping-rate-priority-medium-burst") | str("cos-shaping-rate-priority-low") | str("cos-shaping-rate-priority-low-burst") | str("cos-shaping-rate-excess-high") | str("cos-shaping-rate-excess-high-burst") | str("cos-shaping-rate-excess-low") | str("cos-shaping-rate-excess-low-burst") | str("cos-guaranteed-rate-burst") | str("cos-traffic-control-profile-remaining") | str("routing-instances") | str("pim-enable") | str("interface-mtu") | str("inner-vlan-tag-protocol-id") | str("routing-services") | str("aggregation-interface-set-name") | str("interface-set-name") | str("default-interface-set-name") | str("phy-ifd-interface-set-name") | str("phy-ifd-underlying-intf-set-name")).as(:arg),
        c(
            arg
        )
      )
    end

    rule(:cfm_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("configuration") | str("routing-socket") | str("protocol") | str("init") | str("error") | str("issu") | str("all"))).as(:oneline)
        )
    end

    rule(:flow_interface_group) do
        ca(
            str("exclude")
        ).as(:oneline)
    end

    rule(:flow_route_inet6) do
      b(arg.as(:arg),
        c(
            str("no-install"),
            b(str("match"),
              flow_route_qualifier_inet6
            ),
            b(str("then"),
              flow_route_op
            )
        )
      )
    end

    rule(:flow_route_op) do
        c(
            a(str("community"), arg),
            c(
              str("accept"),
              str("discard"),
              a(str("rate-limit"), arg)
            ),
            a(str("routing-instance"), arg),
            str("sample"),
            a(str("mark"), arg),
            str("next-term"),
            c(
              b(str("redirect"),
                ipaddr
              )
            )
        )
    end

    rule(:flow_route_qualifier_inet6) do
        c(
            b(str("protocol"),
              (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
            ),
            b(str("port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("destination-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("source-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("tcp-flags"),
              (str("fin") | str("syn") | str("rst") | str("push") | str("ack") | str("urgent") | arg)
            ),
            b(str("packet-length"),
              policy_algebra
            ),
            b(str("dscp"),
              policy_algebra
            ),
            b(str("fragment"),
              (str("dont-fragment") | str("not-a-fragment") | str("is-fragment") | str("first-fragment") | str("last-fragment"))
            ),
            b(str("destination"),
              flow_prefix_with_offset
            ),
            b(str("source"),
              flow_prefix_with_offset
            ),
            b(str("icmp6-type"),
              (str("echo-request") | str("echo-reply") | str("destination-unreachable") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("packet-too-big") | str("membership-query") | str("membership-report") | str("membership-termination") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | arg)
            ),
            b(str("icmp6-code"),
              (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
            ),
            b(str("flow-label"),
              policy_algebra
            )
        )
    end

    rule(:flow_prefix_with_offset) do
        c(
              ipv6prefix,
            a(str("prefix-offset"), arg)
        ).as(:oneline)
    end

    rule(:flow_validation) do
        c(
            b(str("traceoptions"),
              flow_dep_traceoptions
            )
        )
    end

    rule(:flow_dep_traceoptions) do
        c(
            b(str("file"),
                sc(
                      arg,
                    str("replace"),
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("no-stamp"),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            a(str("flag"), enum(str("resolution") | str("flash") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                sc(
                    str("send"),
                    str("receive"),
                    str("detail"),
                    str("disable"),
                    b(str("filter"),
                        sc(
                            b(str("match-on"),
                              (str("prefix") | str("route-attribute"))
                            ),
                            b(str("policy"),
                              policy_algebra
                            )
                        )
                    ).as(:oneline)
                )
            ).as(:oneline)
        )
    end

    rule(:juniper_dynamic_profile_varset_object) do
      b(arg.as(:arg),
        c(
            a(str("junos-mep-id"), arg),
            a(str("junos-md-level"), arg),
            a(str("junos-remote-mep-id"), arg),
            a(str("junos-md-name"), arg),
            a(str("junos-ma-name"), arg),
            a(str("junos-loss-threshold"), arg),
            b(str("junos-md-name-format"),
              (str("none") | str("dns") | str("mac+2oct") | str("character-string"))
            ),
            b(str("junos-ma-name-format"),
              (str("2octet") | str("rfc-2685-vpn-id") | str("vlan") | str("character-string") | str("icc"))
            ),
            b(str("junos-ccm-interval"),
              (str("10ms") | str("100ms") | str("1s") | str("10s") | str("1m") | str("10m"))
            ),
            a(str("junos-action-profile"), arg),
            a(str("junos-layer2-output-policer"), arg)
        )
      )
    end

    rule(:juniper_dynamic_variable_object) do
      b(arg.as(:arg),
        c(
            a(str("equals"), arg),
            a(str("default-value"), arg),
            str("mandatory"),
            str("uid-reference"),
            str("uid")
        )
      )
    end

    rule(:juniper_fabric_routing_instance) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("instance-type"),
              (str("vrf"))
            ),
            b(str("route-distinguisher"),
                sc(
                    arg
                )
            ).as(:oneline),
            b(str("routing-options"),
              juniper_fabric_routing_options
            )
        )
      )
    end

    rule(:juniper_fabric_routing_options) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("parse") | str("regex-parse") | str("config-internal") | str("nsr-synchronization") | str("condition-manager") | str("graceful-restart") | str("session") | str("hfrr-fsm") | str("hfrr-route") | str("statistics-id-group") | str("route-record") | str("jvision-lsp") | str("dyn-nh-template") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all") | str("eswd") | str("arp") | str("prefix") | str("ne-port") | str("route-selection") | str("bridge") | str("grat-arp") | str("l2l3-map")),
                        sc(
                            str("disable"),
                            str("send"),
                            str("receive"),
                            str("detail")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-duration"), arg)
                )
            ),
            b(str("resolution"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("event") | str("flash") | str("kernel") | str("indirect") | str("task") | str("igp-frr") | str("igp-frr-extensive") | str("tunnel") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("multicast"),
                c(
                    str("l2-root"),
                    str("replication"),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("vccpdf") | str("root") | str("core") | str("edge") | str("cspf") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    str("no-make-before-break"),
                    a(str("make-before-break-timeout"), arg),
                    str("no-make-before-break-convergence"),
                    a(str("make-before-break-convergence-timeout"), arg),
                    a(str("ic-node-recomputation-delay-timeout"), arg),
                    str("fabric-optimized-distribution")
                )
            ),
            b(str("forwarding-table"),
              forwarding_table_type
            ),
            b(str("auto-export"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("export") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
    end

    rule(:forwarding_table_type) do
        c(
            a(str("remnant-holdtime"), arg),
            a(str("chain-composite-max-label-count"), arg),
            a(str("krt-nexthop-ack-timeout"), arg),
            b(str("consistency-checking"),
                c(
                      (str("enable") | str("disable")),
                    a(str("period"), arg),
                    a(str("threshold"), arg)
                )
            ),
            b(str("export"),
              policy_algebra
            ),
            str("dynamic-list-next-hop"),
            str("ecmp-fast-reroute"),
            str("no-ecmp-fast-reroute"),
            str("indirect-next-hop"),
            str("no-indirect-next-hop"),
            str("indirect-next-hop-change-acknowledgements"),
            str("no-indirect-next-hop-change-acknowledgements"),
            a(str("rib"), arg).as(:oneline),
            b(str("unicast-reverse-path"),
              (str("active-paths") | str("feasible-paths"))
            ),
            b(str("ip-tunnel-rpf-check"),
                c(
                    b(str("mode"),
                      (str("strict") | str("loose"))
                    ),
                    a(str("fail-filter"), arg)
                )
            ),
            str("transit-lsp-statistics-from-route"),
            b(str("chained-composite-next-hop"),
                c(
                    b(str("ingress"),
                        c(
                            str("l2vpn"),
                            str("no-l2vpn"),
                            str("l2ckt"),
                            str("no-l2ckt"),
                            str("fec129-vpws"),
                            str("no-fec129-vpws"),
                            str("evpn"),
                            str("no-evpn"),
                            b(str("labeled-bgp"),
                                c(
                                    str("inet"),
                                    str("no-inet"),
                                    str("inet6"),
                                    str("no-inet6")
                                )
                            ),
                            b(str("l3vpn"),
                                sc(
                                    str("extended-space")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("transit"),
                        c(
                            str("l2vpn"),
                            str("no-l2vpn"),
                            str("l3vpn"),
                            str("no-l3vpn"),
                            str("labeled-bgp"),
                            str("no-labeled-bgp"),
                            str("static"),
                            str("no-static"),
                            str("rsvp"),
                            str("no-rsvp"),
                            str("rsvp-p2mp"),
                            str("no-rsvp-p2mp"),
                            str("ldp"),
                            str("no-ldp"),
                            str("ldp-p2mp"),
                            str("no-ldp-p2mp"),
                            str("labeled-isis"),
                            str("no-labeled-isis")
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_forwarding_options) do
        c(
            b(a(str("storm-control-profiles"), arg),
                c(
                    b(str("all"),
                        c(
                            c(
                              a(str("bandwidth-percentage"), arg),
                              a(str("bandwidth-level"), arg)
                            ),
                            a(str("burst-size"), arg),
                            str("no-broadcast"),
                            str("no-unknown-unicast"),
                            c(
                              str("no-multicast"),
                              str("no-registered-multicast"),
                              str("no-unregistered-multicast")
                            )
                        )
                    ),
                    str("action-shutdown")
                )
            ),
            c(
              b(str("sampling"),
                juniper_sampling_options
              ),
              b(str("packet-capture"),
                juniper_packet_capture_options
              )
            ),
            b(str("monitoring"),
              juniper_monitoring_options
            ),
            b(str("accounting"),
              juniper_packet_accounting_options
            ),
            b(str("analyzer"),
              smpl_analyzer_type
            ),
            b(str("port-mirroring"),
              juniper_port_mirror_options
            ),
            b(str("multicast-replication"),
                c(
                    str("ingress"),
                    str("local-latency-fairness"),
                    b(str("evpn"),
                        c(
                            b(str("irb"),
                              (str("local-only") | str("local-remote"))
                            ),
                            a(str("smet-nexthop-limit"), arg)
                        )
                    )
                )
            ),
            b(str("load-balance"),
                c(
                    str("ecmp-local-bias"),
                    str("indexed-load-balance"),
                    b(str("per-flow"),
                        c(
                            str("hash-seed")
                        )
                    ),
                    b(str("per-prefix"),
                        c(
                            a(str("hash-seed"), arg)
                        )
                    )
                )
            ),
            b(str("hash-key"),
              junos_hash_key
            ),
            b(str("local-bias"),
                c(
                    str("disable")
                )
            ),
            b(str("enhanced-hash-key"),
                c(
                    str("use-trunk-max-links"),
                    str("ecmp-resilient-hash"),
                    b(str("fabric-load-balance"),
                        c(
                            c(
                              b(str("flowlet"),
                                  c(
                                      b(str("inactivity-interval"),
                                        (str("16us") | str("64us") | str("512us") | str("32ms"))
                                      )
                                  )
                              ),
                              str("per-packet")
                            )
                        )
                    ),
                    b(str("hash-mode"),
                        c(
                            c(
                              str("layer2-header"),
                              str("layer2-payload"),
                              a(str("gtp-header-offset"), arg)
                            )
                        )
                    ),
                    b(str("hash-parameters"),
                        c(
                            b(str("ecmp"),
                                c(
                                    a(str("offset"), arg),
                                    b(str("preprocess"),
                                        c(
                                            c(
                                              str("enable"),
                                              str("disable")
                                            )
                                        )
                                    ),
                                    b(str("function"),
                                        c(
                                            c(
                                              str("crc16-bisync"),
                                              str("crc16-ccitt"),
                                              str("crc32-hi"),
                                              str("crc32-lo")
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("lag"),
                                c(
                                    a(str("offset"), arg),
                                    b(str("preprocess"),
                                        c(
                                            c(
                                              str("preprocess-enable"),
                                              str("preprocess-disable")
                                            )
                                        )
                                    ),
                                    b(str("function"),
                                        c(
                                            c(
                                              str("crc16-bisync"),
                                              str("crc16-ccitt"),
                                              str("crc32-hi"),
                                              str("crc32-lo")
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("hash-seed"),
                        c(
                              arg
                        )
                    ),
                    b(str("resilient-hash-seed"),
                        c(
                              arg
                        )
                    ),
                    b(str("mpls"),
                        c(
                            str("no-incoming-port"),
                            str("no-incoming-device")
                        )
                    ),
                    b(str("layer2"),
                        c(
                            str("no-incoming-port"),
                            str("no-incoming-device"),
                            str("no-source-mac-address"),
                            str("source-mac-address"),
                            str("no-destination-mac-address"),
                            str("destination-mac-address"),
                            str("no-ether-type"),
                            str("vlan-id"),
                            str("no-vlan-id"),
                            str("inner-vlan-id")
                        )
                    ),
                    b(str("inet"),
                        c(
                            str("no-incoming-port"),
                            str("no-incoming-device"),
                            str("no-l4-source-port"),
                            str("no-l4-destination-port"),
                            str("no-protocol"),
                            str("no-ipv4-source-address"),
                            str("no-ipv4-destination-address"),
                            str("vlan-id")
                        )
                    ),
                    b(str("inet6"),
                        c(
                            str("no-incoming-port"),
                            str("no-incoming-device"),
                            str("no-l4-source-port"),
                            str("no-l4-destination-port"),
                            str("ipv6-flow-label"),
                            str("no-next-header"),
                            str("no-ipv6-source-address"),
                            str("no-ipv6-destination-address"),
                            str("vlan-id")
                        )
                    ),
                    str("no-mpls"),
                    b(str("gre"),
                        c(
                            str("key"),
                            str("protocol")
                        )
                    ),
                    str("vxlan-vnid"),
                    b(str("services-loadbalancing"),
                        c(
                            b(str("family"),
                                c(
                                    b(str("inet"),
                                        c(
                                            b(str("layer-3-services"),
                                                c(
                                                    str("source-address"),
                                                    str("destination-address"),
                                                    str("incoming-interface-index")
                                                )
                                            )
                                        )
                                    ),
                                    b(str("inet6"),
                                        c(
                                            b(str("layer-3-services"),
                                                c(
                                                    str("source-address"),
                                                    str("destination-address"),
                                                    str("incoming-interface-index"),
                                                    a(str("src-prefix-len"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("source-destination-only-loadbalancing"),
                        c(
                            b(str("family"),
                                c(
                                    b(str("inet"),
                                        c(
                                            a(str("prefix-length"), arg)
                                        )
                                    ),
                                    b(str("inet6"),
                                        c(
                                            a(str("prefix-length"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    str("incoming-interface-index"),
                                    str("no-destination-port"),
                                    str("no-source-port"),
                                    str("type-of-service"),
                                    str("gtp-tunnel-endpoint-identifier"),
                                    str("l2tp-tunnel-session-identifier"),
                                    str("session-id")
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    str("incoming-interface-index"),
                                    str("traffic-class"),
                                    str("no-destination-port"),
                                    str("no-source-port"),
                                    str("gtp-tunnel-endpoint-identifier"),
                                    str("session-id"),
                                    str("no-flow-label")
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    str("label-1-exp"),
                                    str("incoming-interface-index"),
                                    c(
                                      str("no-ether-pseudowire"),
                                      b(str("ether-pseudowire"),
                                          sc(
                                              str("zero-control-word")
                                          )
                                      ).as(:oneline)
                                    ),
                                    str("no-payload")
                                )
                            ),
                            b(str("multiservice"),
                                c(
                                    str("incoming-interface-index"),
                                    str("outer-priority"),
                                    str("no-payload"),
                                    str("no-mac-addresses")
                                )
                            )
                        )
                    ),
                    b(str("hash-function"),
                        c(
                            c(
                              str("CRC16-CCITT"),
                              str("CRC16"),
                              str("CRC16XOR1"),
                              str("CRC16XOR2"),
                              str("CRC16XOR4"),
                              str("CRC16XOR8"),
                              str("CRC32HI"),
                              str("CRC32LO"),
                              b(str("xor"),
                                  c(
                                      str("no-L3-L4-headers"),
                                      str("no-L4-ports"),
                                      str("mac-addresses"),
                                      str("no-mpls-hash"),
                                      str("no-ipv4-source-address"),
                                      str("no-ipv4-destination-address"),
                                      str("no-ipv6-source-address"),
                                      str("no-ipv6-destination-address"),
                                      str("no-ip6-flow-label"),
                                      str("en-ip-over-mpls"),
                                      str("no-mpls-label0"),
                                      str("no-mpls-label1"),
                                      str("no-source-mac-address"),
                                      str("no-destination-mac-address"),
                                      str("no-l4-source-port"),
                                      str("no-l4-destination-port")
                                  )
                              ),
                              str("ingress-port"),
                              b(str("crc6"),
                                  c(
                                      a(str("crc6-seed"), arg),
                                      str("en-ip-over-mpls"),
                                      str("no-source-mac-address"),
                                      str("no-destination-mac-address"),
                                      str("no-mpls-label0"),
                                      str("no-mpls-label1"),
                                      str("no-l4-source-port"),
                                      str("no-l4-destination-port"),
                                      str("no-ip-source-address"),
                                      str("no-ip-destination-address"),
                                      str("no-ip6-flow-label")
                                  )
                              ),
                              b(str("crc16"),
                                  c(
                                      a(str("crc16-seed"), arg),
                                      str("en-ip-over-mpls"),
                                      str("no-source-mac-address"),
                                      str("no-destination-mac-address"),
                                      str("no-mpls-label0"),
                                      str("no-mpls-label1"),
                                      str("no-l4-source-port"),
                                      str("no-l4-destination-port"),
                                      str("no-ip-source-address"),
                                      str("no-ip-destination-address"),
                                      str("no-ip6-flow-label")
                                  )
                              )
                            )
                        )
                    ),
                    str("symmetric")
                )
            ),
            b(str("next-hop"),
                c(
                    a(str("arp-throttle"), arg),
                    a(str("arp-detect"), arg)
                )
            ),
            b(str("multicast"),
                c(
                    a(str("resolve-rate"), arg),
                    a(str("mismatch-rate"), arg),
                    b(str("policer"),
                        c(
                            a(str("bandwidth-limit"), arg),
                            a(str("burst-size-limit"), arg)
                        )
                    )
                )
            ),
            b(str("rpf-loose-mode-discard"),
                c(
                    b(str("family"),
                        c(
                            str("inet6"),
                            str("inet")
                        )
                    )
                )
            ),
            str("l2circuit-control-passthrough"),
            b(str("explicit-null-cos"),
                c(
                    str("inet6"),
                    str("inet")
                )
            ),
            b(str("helpers"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            b(str("level"),
                              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                            ),
                            a(str("flag"), enum(str("trace") | str("address") | str("main") | str("config") | str("ifdb") | str("io") | str("rtsock") | str("ui") | str("util") | str("gencfg") | str("domain") | str("tftp") | str("bootp") | str("port") | str("if-rtsdb") | str("all"))).as(:oneline)
                        )
                    ),
                    b(str("rtsdb-client-traceoptions"),
                        c(
                            b(str("if-rtsdb"),
                                c(
                                    a(str("flag"), enum(str("init") | str("routing-socket") | str("map") | str("all")),
                                        sc(
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("domain"),
                        c(
                            a(str("description"), quote | arg),
                            b(str("server"),
                                sc(
                                      ipv4addr,
                                    c(
                                      b(str("logical-system"),
                                          sc(
                                              arg,
                                              a(str("routing-instance"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("routing-instance"), arg)
                                    )
                                )
                            ).as(:oneline),
                            b(a(str("interface"), arg),
                                c(
                                    str("no-listen"),
                                    str("broadcast"),
                                    a(str("description"), quote | arg),
                                    b(str("server"),
                                        sc(
                                              ipv4addr,
                                            c(
                                              b(str("logical-system"),
                                                  sc(
                                                      arg,
                                                      a(str("routing-instance"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("routing-instance"), arg)
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("tftp"),
                        c(
                            a(str("description"), quote | arg),
                            b(str("server"),
                                sc(
                                      ipv4addr,
                                    c(
                                      b(str("logical-system"),
                                          sc(
                                              arg,
                                              a(str("routing-instance"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("routing-instance"), arg)
                                    )
                                )
                            ).as(:oneline),
                            b(a(str("interface"), arg),
                                c(
                                    str("no-listen"),
                                    str("broadcast"),
                                    a(str("description"), quote | arg),
                                    b(str("server"),
                                        sc(
                                              ipv4addr,
                                            c(
                                              b(str("logical-system"),
                                                  sc(
                                                      arg,
                                                      a(str("routing-instance"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("routing-instance"), arg)
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("bootp"),
                        c(
                            str("relay-agent-option"),
                            b(str("dhcp-option82"),
                              dhcp_option82_type
                            ),
                            a(str("description"), quote | arg),
                            b(a(str("server"), arg),
                                c(
                                    b(a(str("logical-system"), arg),
                                        sc(
                                            a(str("routing-instance"), arg)
                                        )
                                    ).as(:oneline),
                                    a(str("routing-instance"), arg)
                                )
                            ),
                            a(str("maximum-hop-count"), arg),
                            a(str("minimum-wait-time"), arg),
                            a(str("client-response-ttl"), arg),
                            str("source-address-giaddr"),
                            str("vpn"),
                            str("apply-secondary-as-giaddr"),
                            b(a(str("interface"), arg),
                                c(
                                    str("no-listen"),
                                    str("broadcast"),
                                    a(str("description"), quote | arg),
                                    b(a(str("server"), arg),
                                        c(
                                            b(a(str("logical-system"), arg),
                                                sc(
                                                    a(str("routing-instance"), arg)
                                                )
                                            ).as(:oneline),
                                            a(str("routing-instance"), arg)
                                        )
                                    ),
                                    a(str("maximum-hop-count"), arg),
                                    a(str("minimum-wait-time"), arg),
                                    a(str("client-response-ttl"), arg),
                                    str("source-address-giaddr"),
                                    str("vpn"),
                                    b(str("dhcp-option82"),
                                      dhcp_option82_type
                                    ),
                                    str("apply-secondary-as-giaddr")
                                )
                            )
                        )
                    ),
                    b(a(str("port"), arg),
                        c(
                            a(str("description"), quote | arg),
                            b(a(str("server"), arg),
                                c(
                                    c(
                                      b(str("logical-system"),
                                          sc(
                                              arg,
                                              a(str("routing-instance"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("routing-instance"), arg)
                                    )
                                )
                            ),
                            b(a(str("interface"), arg),
                                c(
                                    str("no-listen"),
                                    str("broadcast"),
                                    a(str("description"), quote | arg),
                                    b(a(str("server"), arg),
                                        c(
                                            c(
                                              b(str("logical-system"),
                                                  sc(
                                                      arg,
                                                      a(str("routing-instance"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("routing-instance"), arg)
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            b(str("filter"),
                                c(
                                    a(str("input"), arg),
                                    a(str("output"), arg)
                                )
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                            b(str("filter"),
                                c(
                                    a(str("input"), arg),
                                    a(str("output"), arg)
                                )
                            ),
                            str("route-accounting"),
                            str("source-checking")
                        )
                    ),
                    b(str("mpls"),
                        c(
                            b(str("filter"),
                                c(
                                    a(str("input"), arg),
                                    a(str("output"), arg)
                                )
                            )
                        )
                    ),
                    b(str("vpls"),
                        c(
                            b(str("filter"),
                                c(
                                    a(str("input"), arg)
                                )
                            ),
                            b(str("flood"),
                                c(
                                    a(str("input"), arg)
                                )
                            )
                        )
                    ),
                    b(str("evpn"),
                        c(
                            b(str("filter"),
                                c(
                                    a(str("input"), arg)
                                )
                            ),
                            b(str("flood"),
                                c(
                                    a(str("input"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("next-hop-group"),
              juniper_next_hop_group_options
            ),
            b(str("dhcp-relay"),
              jdhcp_relay_type
            ),
            str("load-balance-label-capability"),
            str("no-load-balance-label-capability"),
            b(str("fast-reroute-priority"),
              (str("low") | str("medium") | str("high"))
            ),
            b(a(str("ip-options-protocol-queue"), arg),
                c(
                    a(str("protocol-id"), arg),
                    a(str("queue-depth"), arg)
                )
            ),
            str("link-layer-broadcast-inet-check"),
            str("cut-through"),
            b(str("storm-control"),
                c(
                    str("enhanced")
                )
            ),
            str("vrf-fallback"),
            str("mpls-tunnel-extend"),
            str("vxlan-disable-copy-tos-encap"),
            str("vxlan-disable-copy-tos-decap"),
            str("no-hierarchical-ecmp"),
            str("ipmc-miss-do-l2mc"),
            str("hyper-mode"),
            str("no-hyper-mode"),
            str("ecmp-do-local-lookup"),
            b(str("access-security"),
              jdhcp_access_security_type
            ),
            b(str("forwarding-sandbox"),
              juniper_forwarding_sandbox_options
            ),
            b(str("vxlan-routing"),
                c(
                    a(str("next-hop"), arg),
                    a(str("interface-num"), arg),
                    str("overlay-ecmp")
                )
            ),
            b(str("satellite"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("all") | str("bd") | str("config-internal") | str("interface") | str("interface-vlan") | str("ipc") | str("kernel") | str("krt") | str("mac") | str("nh") | str("normal") | str("parse") | str("stp") | str("task") | str("timer") | str("firewall") | str("l3") | str("fip-snooping"))).as(:oneline)
                        )
                    ),
                    str("local-replication"),
                    b(a(str("fpc"), arg),
                        c(
                            c(
                              b(str("local-switching"),
                                  c(
                                      str("l3")
                                  )
                              ),
                              b(str("selective-vlan-switching"),
                                  c(
                                      a(str("routing-instance"), arg)
                                  )
                              )
                            )
                        )
                    ),
                    b(str("vlan-auto-sense"),
                        c(
                            a(str("expiry-time"), arg)
                        )
                    ),
                    b(str("analyzer-vlan"),
                        c(
                            arg
                        )
                    ),
                    str("disable-heartbeat"),
                    str("no-disable-heartbeat")
                )
            )
        )
    end

    rule(:dhcp_option82_type) do
        c(
            str("disable"),
            b(str("circuit-id"),
                c(
                    b(str("prefix"),
                      (str("hostname"))
                    ),
                    str("use-interface-description"),
                    str("use-vlan-id")
                )
            ),
            b(str("remote-id"),
                c(
                    b(str("prefix"),
                      (str("none") | str("hostname") | str("mac"))
                    ),
                    str("use-interface-description"),
                    a(str("use-string"), arg)
                )
            ),
            b(str("vendor-id"),
                c(
                    arg
                )
            )
        )
    end

    rule(:jdhcp_access_security_type) do
        c(
            b(str("slaac-snooping"),
              slaacd_config_type
            ),
            b(str("router-advertisement-guard"),
                c(
                    b(a(str("policy"), arg),
                        c(
                            b(str("discard"),
                                c(
                                    a(str("source-ip-address-list"), arg),
                                    a(str("source-mac-address-list"), arg),
                                    a(str("prefix-list-name"), arg)
                                )
                            ),
                            b(str("accept"),
                                c(
                                    b(str("match-list"),
                                        c(
                                            a(str("source-ip-address-list"), arg),
                                            a(str("source-mac-address-list"), arg),
                                            a(str("prefix-list-name"), arg),
                                            b(str("match-criteria"),
                                              (str("match-all") | str("match-any"))
                                            )
                                        )
                                    ),
                                    b(str("match-options"),
                                        c(
                                            b(str("hop-limit"),
                                                c(
                                                    a(str("maximum"), arg),
                                                    a(str("minimum"), arg)
                                                )
                                            ),
                                            b(str("route-preference"),
                                                c(
                                                    b(str("maximum"),
                                                      (str("low") | str("medium") | str("high"))
                                                    )
                                                )
                                            ),
                                            str("managed-config-flag"),
                                            str("other-config-flag")
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("interface"),
                        c(
                              interface_policy
                        )
                    ),
                    b(str("vlans"),
                        c(
                              vlan_policy
                        )
                    )
                )
            )
        )
    end

    rule(:interface_policy) do
      b(arg.as(:arg),
        c(
            b(str("policy"),
                ca(
                    c(
                      str("stateful"),
                      str("stateless")
                    )
                )
            ),
            b(str("mark-interface"),
                c(
                    c(
                      str("trusted"),
                      str("block")
                    )
                )
            )
        )
      )
    end

    rule(:juniper_forwarding_sandbox_options) do
      b(arg.as(:arg),
        c(
            b(str("size"),
              (str("small") | str("medium") | str("large"))
            ),
            b(str("port"),
              juniper_forwarding_sandbox_port_options
            )
        )
      )
    end

    rule(:juniper_forwarding_sandbox_port_options) do
      b(arg.as(:arg),
        c(
            a(str("interface"), arg)
        )
      )
    end

    rule(:juniper_gnf) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("control-plane-bandwidth-percent"), arg),
            a(str("fpcs"), arg),
              abstract_interface_type
        )
      )
    end

    rule(:abstract_interface_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("peer-gnf"),
                sc(
                    a(str("id"), arg),
                      arg
                )
            ).as(:oneline)
        )
      )
    end

    rule(:juniper_logical_system) do
      b(arg.as(:arg),
        c(
            b(str("interfaces"),
                c(
                      lr_interfaces_type
                )
            ),
            b(str("protocols"),
              juniper_protocols
            ),
            b(str("policy-options"),
              juniper_policy_options
            ),
            b(str("routing-instances"),
                c(
                      juniper_routing_instance
                )
            ),
            b(str("routing-options"),
              juniper_routing_options
            ),
            b(str("forwarding-options"),
                c(
                    b(str("dhcp-relay"),
                      jdhcp_relay_type
                    ),
                    b(a(str("storm-control-profiles"), arg),
                        c(
                            b(str("all"),
                                c(
                                    c(
                                      a(str("bandwidth-percentage"), arg),
                                      a(str("bandwidth-level"), arg)
                                    ),
                                    a(str("burst-size"), arg),
                                    str("no-broadcast"),
                                    str("no-unknown-unicast"),
                                    c(
                                      str("no-multicast"),
                                      str("no-registered-multicast"),
                                      str("no-unregistered-multicast")
                                    )
                                )
                            ),
                            str("action-shutdown")
                        )
                    ),
                    b(str("sampling"),
                        c(
                            b(str("family"),
                                c(
                                    b(str("inet"),
                                        c(
                                            b(str("output"),
                                                c(
                                                    b(str("flow-server"),
                                                      cflowd_sampling_inet_lr_type
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("mpls"),
                                        c(
                                            b(str("output"),
                                                c(
                                                    b(str("flow-server"),
                                                      cflowd_sampling_mpls_lr_type
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("instance"), arg),
                                c(
                                      (str("disable")),
                                    b(str("family"),
                                        c(
                                            b(str("inet"),
                                                c(
                                                    b(str("output"),
                                                        c(
                                                            b(str("flow-server"),
                                                              cflowd_sampling_inet_lr_inst_type
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("mpls"),
                                                c(
                                                    b(str("output"),
                                                        c(
                                                            b(str("flow-server"),
                                                              cflowd_sampling_mpls_lr_inst_type
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("system"),
                c(
                    b(str("arp"),
                        c(
                            a(str("aging-timer"), arg),
                            b(str("interfaces"),
                                c(
                                      arp_interface_type
                                )
                            ),
                            str("passive-learning"),
                            str("purging"),
                            str("gratuitous-arp-on-ifup"),
                            a(str("gratuitous-arp-delay"), arg),
                            str("non-subscriber-no-reply"),
                            str("proactive-arp-detection")
                        )
                    ),
                    b(str("services"),
                        c(
                            b(str("dhcp-local-server"),
                              jdhcp_local_server_type
                            ),
                            b(str("dhcp-proxy-client"),
                              jdhcp_proxy_client_type
                            ),
                            b(str("static-subscribers"),
                              jsscd_static_subscribers_type
                            ),
                            b(str("tcp-forwarding"),
                                c(
                                    b(str("listening-port"),
                                        s(
                                                arg,
                                          a(str("listening-address"), arg),
                                          c(
                                            b(str("forwarding-address"),
                                              ipv4addr
                                            ),
                                            a(str("forwarding-port"), arg),
                                            a(str("max-connections"), arg),
                                            a(str("allowed-source"), arg)
                                          )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("processes"),
                        c(
                            b(str("routing"),
                                c(
                                    c(
                                      str("force-32-bit"),
                                      str("force-64-bit"),
                                      str("auto-64-bit")
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("access"),
                c(
                    b(str("address-assignment"),
                      address_assignment_type
                    ),
                    b(str("address-protection"),
                        c(
                            str("reassign-on-match")
                        )
                    )
                )
            ),
            b(str("access-profile"),
                sc(
                    arg
                )
            ).as(:oneline),
            b(str("firewall"),
                c(
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("dialer-filter"),
                                      inet_dialer_filter
                                    ),
                                    b(str("prefix-action"),
                                      prefix_action
                                    ),
                                    b(str("filter"),
                                      inet_filter
                                    ),
                                    b(str("template"),
                                      inet_template
                                    ),
                                    b(str("simple-filter"),
                                      inet_simple_filter
                                    ),
                                    b(str("service-filter"),
                                      inet_service_filter
                                    ),
                                    b(str("fast-update-filter"),
                                      inet_fuf
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("dialer-filter"),
                                      inet6_dialer_filter
                                    ),
                                    b(str("filter"),
                                      inet6_filter
                                    ),
                                    b(str("service-filter"),
                                      inet6_service_filter
                                    ),
                                    b(str("fast-update-filter"),
                                      inet6_fuf
                                    ),
                                    b(str("template"),
                                      inet6_template
                                    )
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    b(str("dialer-filter"),
                                      mpls_dialer_filter
                                    ),
                                    b(str("filter"),
                                      mpls_filter
                                    ),
                                    b(str("template"),
                                      mpls_template
                                    )
                                )
                            ),
                            b(str("vpls"),
                                c(
                                    b(str("filter"),
                                      vpls_filter
                                    )
                                )
                            ),
                            b(str("evpn"),
                                c(
                                    b(str("filter"),
                                      vpls_filter
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                    b(str("filter"),
                                      bridge_filter
                                    )
                                )
                            ),
                            b(str("ccc"),
                                c(
                                    b(str("filter"),
                                      ccc_filter
                                    )
                                )
                            ),
                            b(str("any"),
                                c(
                                    b(str("filter"),
                                      any_filter
                                    ),
                                    b(str("template"),
                                      any_template
                                    )
                                )
                            ),
                            b(str("ethernet-switching"),
                                c(
                                    b(str("filter"),
                                      es_filter
                                    ),
                                    b(str("template"),
                                      es_template
                                    )
                                )
                            )
                        )
                    ),
                    b(str("policer"),
                      firewall_policer
                    ),
                    b(str("flexible-match"),
                      firewall_flexible_match
                    ),
                    b(str("tunnel-end-point"),
                      tunnel_end_point
                    ),
                    b(str("hierarchical-policer"),
                      firewall_hierpolicer
                    ),
                    b(str("interface-set"),
                      interface_set_type
                    ),
                    b(str("load-balance-group"),
                      firewall_load_balance_group
                    ),
                    b(str("atm-policer"),
                      atm_policer_type
                    ),
                    b(str("three-color-policer"),
                      three_color_policer_type
                    ),
                    b(str("filter"),
                      inet_filter
                    )
                )
            ),
            b(str("multicast-snooping-options"),
              juniper_multicast_snooping_options
            ),
            b(str("services"),
                c(
                    b(str("flow-monitoring"),
                        c(
                            b(str("version9"),
                                c(
                                    b(str("template"),
                                      version9_template
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("bridge-domains"),
                c(
                      juniper_bridge_domains
                )
            ),
            b(str("switch-options"),
              juniper_def_rtb_switch_options
            ),
            b(str("vlans"),
                c(
                      vlan_types
                )
            )
        )
      )
    end

    rule(:arp_interface_type) do
      b(arg.as(:arg),
        c(
            a(str("aging-timer"), arg)
        )
      )
    end

    rule(:cflowd_sampling_inet_lr_inst_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:aggregation_type) do
        c(
            str("autonomous-system"),
            str("protocol-port"),
            str("source-prefix"),
            str("destination-prefix"),
            b(str("source-destination-prefix"),
                c(
                    str("caida-compliant")
                )
            )
        )
    end

    rule(:cflowd_sampling_inet_lr_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:cflowd_sampling_mpls_lr_inst_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:cflowd_sampling_mpls_lr_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:jdhcp_local_server_type) do
        c(
            b(str("traceoptions"),
              jdhcp_traceoptions_type
            ),
            b(str("interface-traceoptions"),
              jdhcp_interface_traceoptions_type
            ),
            b(str("dhcpv6"),
              dhcpv6_local_server_type
            ),
            a(str("pool-match-order"), enum(str("external-authority") | str("ip-address-first") | str("option-82") | str("option-82-strict"))),
            str("duplicate-clients-on-interface"),
            b(str("duplicate-clients-in-subnet"),
              jdhcp_duplicate_clients_in_subnet_type
            ).as(:oneline),
            b(str("forward-snooped-clients"),
                sc(
                    c(
                      str("configured-interfaces"),
                      str("non-configured-interfaces"),
                      str("all-interfaces")
                    )
                )
            ).as(:oneline),
            b(str("authentication"),
              authentication_type
            ),
            b(str("liveness-detection"),
              dhcp_liveness_detection_type
            ),
            b(str("reconfigure"),
              reconfigure_type
            ),
            b(str("overrides"),
              override_local_server_type
            ),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline),
            b(str("route-suppression"),
              dhcp_route_suppression_type
            ),
            b(str("group"),
              dhcp_local_server_group
            ),
            b(str("dual-stack-group"),
              dhcp_local_server_dual_stack_group
            ),
            b(str("lease-time-validation"),
                c(
                    a(str("lease-time-threshold"), arg),
                    b(str("violation-action"),
                        sc(
                            c(
                              str("strict"),
                              str("override-lease")
                            )
                        )
                    ).as(:oneline)
                )
            ),
            c(
              a(str("requested-ip-network-match"), arg),
              str("requested-ip-interface-match")
            ),
            str("no-snoop"),
            b(str("persistent-storage"),
                sc(
                    str("automatic")
                )
            ).as(:oneline),
            b(str("allow-leasequery"),
              server_leasequery_type
            ),
            b(str("remote-id-mismatch"),
              dhcp_remote_id_mismatch_type
            ),
            b(str("reauthenticate"),
                sc(
                    str("lease-renewal"),
                    str("remote-id-mismatch")
                )
            ).as(:oneline),
            b(str("allow-bulk-leasequery"),
              server_bulk_leasequery_type
            ),
            b(str("allow-active-leasequery"),
              server_active_leasequery_type
            )
        )
    end

    rule(:dhcp_local_server_dual_stack_group) do
      b(arg.as(:arg),
        c(
            b(str("authentication"),
              dual_stack_authentication_type
            ),
            a(str("access-profile"), arg),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            a(str("service-profile"), arg),
            str("on-demand-address-allocation"),
            b(str("classification-key"),
              classification_types
            ),
            a(str("dual-stack-interface-client-limit"), arg),
            b(str("protocol-master"),
              jdhcp_dual_stack_protocol_mstr_type
            ).as(:oneline),
            b(str("liveness-detection"),
              dhcp_liveness_detection_dualstack_type
            ),
            b(str("reauthenticate"),
                sc(
                    str("lease-renewal"),
                    str("remote-id-mismatch")
                )
            ).as(:oneline),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:dhcp_local_server_group) do
      b(arg.as(:arg),
        c(
            b(str("authentication"),
              authentication_type
            ),
            b(str("liveness-detection"),
              dhcp_liveness_detection_type
            ),
            b(str("reconfigure"),
              reconfigure_type
            ),
            b(str("overrides"),
              override_local_server_type
            ),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline),
            b(str("route-suppression"),
              dhcp_route_suppression_type
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("upto"),
                      interface_name
                    ),
                    str("exclude"),
                    str("trace"),
                    b(str("overrides"),
                      override_local_server_type
                    ),
                    b(str("dynamic-profile"),
                      dynamic_profile_type
                    ).as(:oneline),
                    a(str("service-profile"), arg),
                    a(str("access-profile"), arg),
                    b(str("short-cycle-protection"),
                        sc(
                            a(str("lockout-min-time"), arg),
                            a(str("lockout-max-time"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("lease-time-validation"),
                c(
                    a(str("lease-time-threshold"), arg),
                    b(str("violation-action"),
                        sc(
                            c(
                              str("strict"),
                              str("override-lease")
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("remote-id-mismatch"),
              dhcp_remote_id_mismatch_type
            ),
            b(str("reauthenticate"),
                sc(
                    str("lease-renewal"),
                    str("remote-id-mismatch")
                )
            ).as(:oneline)
        )
      )
    end

    rule(:dhcpv6_local_server_type) do
        c(
            b(str("authentication"),
              dhcpv6_authentication_type
            ),
            b(str("liveness-detection"),
              dhcpv6_liveness_detection_type
            ),
            b(str("reconfigure"),
              dhcpv6_reconfigure_type
            ),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            b(str("forward-snooped-clients"),
                sc(
                    c(
                      str("configured-interfaces"),
                      str("non-configured-interfaces"),
                      str("all-interfaces")
                    )
                )
            ).as(:oneline),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline),
            b(str("overrides"),
              dhcpv6_override_local_server_type
            ),
            b(str("route-suppression"),
              dhcpv6_route_suppression_type
            ),
            b(str("group"),
              dhcpv6_local_server_group
            ),
            b(str("lease-time-validation"),
                c(
                    a(str("lease-time-threshold"), arg),
                    b(str("violation-action"),
                        sc(
                            c(
                              str("strict"),
                              str("override-lease")
                            )
                        )
                    ).as(:oneline)
                )
            ),
            c(
              a(str("requested-ip-network-match"), arg),
              str("requested-ip-interface-match")
            ),
            str("no-snoop"),
            b(str("persistent-storage"),
                sc(
                    str("automatic")
                )
            ).as(:oneline),
            b(str("server-duid-type"),
              duid_type
            ),
            b(str("remote-id-mismatch"),
              dhcp_remote_id_mismatch_type
            ),
            b(str("reauthenticate"),
                sc(
                    str("lease-renewal"),
                    str("remote-id-mismatch")
                )
            ).as(:oneline),
            b(str("allow-leasequery"),
              server_leasequery_type
            ),
            b(str("allow-bulk-leasequery"),
              server_bulk_leasequery_type
            ),
            b(str("allow-active-leasequery"),
              server_active_leasequery_type
            ),
            b(str("duplicate-clients"),
              dhcpv6_duplicate_clients_type
            ).as(:oneline),
            b(str("dynamic-server"),
              dhcpv6_dynamic_server_type
            )
        )
    end

    rule(:dhcpv6_dynamic_server_type) do
        c(
            b(str("overrides"),
              dhcpv6_override_dynamic_server_type
            ),
            b(str("group"),
              dhcpv6_dynamic_server_group
            )
        )
    end

    rule(:dhcpv6_dynamic_server_group) do
      b(arg.as(:arg),
        c(
            a(str("neighbor-discovery-router-advertisement"), arg),
            b(str("overrides"),
              dhcpv6_override_dynamic_server_type
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("overrides"),
                      dhcpv6_override_dynamic_server_type
                    )
                )
            )
        )
      )
    end

    rule(:dhcpv6_local_server_group) do
      b(arg.as(:arg),
        c(
            b(str("authentication"),
              dhcpv6_authentication_type
            ),
            b(str("liveness-detection"),
              dhcpv6_liveness_detection_type
            ),
            b(str("reconfigure"),
              dhcpv6_reconfigure_type
            ),
            b(str("dynamic-profile"),
              dynamic_profile_type
            ).as(:oneline),
            a(str("service-profile"), arg),
            a(str("access-profile"), arg),
            b(str("short-cycle-protection"),
                sc(
                    a(str("lockout-min-time"), arg),
                    a(str("lockout-max-time"), arg)
                )
            ).as(:oneline),
            b(str("overrides"),
              dhcpv6_override_local_server_type
            ),
            b(str("route-suppression"),
              dhcpv6_route_suppression_type
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("upto"),
                      interface_name
                    ),
                    str("exclude"),
                    str("trace"),
                    b(str("overrides"),
                      dhcpv6_override_local_server_type
                    ),
                    b(str("dynamic-profile"),
                      dynamic_profile_type
                    ).as(:oneline),
                    a(str("service-profile"), arg),
                    a(str("access-profile"), arg),
                    b(str("short-cycle-protection"),
                        sc(
                            a(str("lockout-min-time"), arg),
                            a(str("lockout-max-time"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("lease-time-validation"),
                c(
                    a(str("lease-time-threshold"), arg),
                    b(str("violation-action"),
                        sc(
                            c(
                              str("strict"),
                              str("override-lease")
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("remote-id-mismatch"),
              dhcp_remote_id_mismatch_type
            ),
            b(str("reauthenticate"),
                sc(
                    str("lease-renewal"),
                    str("remote-id-mismatch")
                )
            ).as(:oneline)
        )
      )
    end

    rule(:dhcpv6_override_dynamic_server_type) do
        c(
            a(str("interface-client-limit"), arg),
            str("rapid-commit"),
            b(str("process-inform"),
                c(
                    a(str("pool"), arg)
                )
            ),
            a(str("delegated-pool"), arg),
            a(str("ia-na-pool"), arg)
        )
    end

    rule(:dhcpv6_override_local_server_type) do
        c(
            a(str("interface-client-limit"), arg),
            str("rapid-commit"),
            b(str("client-negotiation-match"),
                sc(
                    c(
                      str("incoming-interface")
                    )
                )
            ).as(:oneline),
            b(str("process-inform"),
                c(
                    a(str("pool"), arg)
                )
            ),
            b(str("delay-advertise"),
              dhcpv6_filter_option
            ),
            a(str("delegated-pool"), arg),
            str("multi-address-embedded-option-response"),
            str("always-process-option-request-option"),
            str("delete-binding-on-renegotiation"),
            str("top-level-status-code"),
            str("always-add-option-dns-server"),
            a(str("asymmetric-lease-time"), arg),
            a(str("asymmetric-prefix-lease-time"), arg),
            a(str("protocol-attributes"), arg),
            a(str("dual-stack"), arg)
        )
    end

    rule(:dhcpv6_filter_option) do
        c(
            a(str("delay-time"), arg),
            b(str("based-on"),
                c(
                    b(str("option-18"),
                        c(
                            b(str("equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("not-equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_v6_option_ascii_hex
                            )
                        )
                    ),
                    b(str("option-37"),
                        c(
                            b(str("equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("not-equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_v6_option_ascii_hex
                            )
                        )
                    ),
                    b(str("option-15"),
                        c(
                            b(str("equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("not-equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_v6_option_ascii_hex
                            )
                        )
                    ),
                    b(str("option-16"),
                        c(
                            b(str("equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("not-equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_v6_option_ascii_hex
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:dhcpv6_reconfigure_type) do
        c(
            str("strict"),
            str("clear-on-abort"),
            a(str("attempts"), arg),
            a(str("timeout"), arg),
            a(str("token"), arg),
            b(str("trigger"),
              reconfigure_trigger_type
            ),
            str("support-option-pd-exclude")
        )
    end

    rule(:duid_type) do
        c(
            str("duid_ll")
        )
    end

    rule(:jdhcp_proxy_client_type) do
        c(
            b(str("dhcpv4-profiles"),
              dhcpv4_profile
            ),
            b(str("dhcpv6-profiles"),
              dhcpv6_profile
            ),
            b(str("traceoptions"),
              jdhcp_traceoptions_type
            )
        )
    end

    rule(:dhcpv4_profile) do
      b(arg.as(:arg),
        c(
            a(str("pool-name"), arg),
            a(str("lease-time"), arg),
            a(str("retransmission-attempt"), arg),
            a(str("retransmission-interval"), arg),
            a(str("dead-server-retry-interval"), arg),
            b(str("dhcp-server-selection-algorithm"),
              (str("highest-priority-server") | str("round-robin"))
            ),
            a(str("dead-server-successive-retry-attempt"), arg),
            b(str("bind-interface"),
              interface_unit
            ),
            b(a(str("servers"), arg),
                c(
                    a(str("priority"), arg)
                )
            )
        )
      )
    end

    rule(:dhcpv6_profile) do
      b(arg.as(:arg),
        c(
            a(str("pool-name"), arg),
            a(str("lease-time"), arg),
            a(str("retransmission-attempt"), arg),
            a(str("retransmission-interval"), arg),
            b(str("bind-interface"),
              interface_unit
            )
        )
      )
    end

    rule(:jsscd_static_subscribers_type) do
        c(
            b(str("access-profile"),
              jsscd_access_profile_type
            ),
            b(str("dynamic-profile"),
              jsscd_dynamic_profile_type
            ),
            b(str("service-profile"),
              jsscd_service_profile_type
            ),
            b(str("authentication"),
              jsscd_authentication_type
            ),
            b(str("group"),
              jsscd_group_type
            ),
            str("auto-login"),
            str("baseline-stats"),
            b(a(str("interface"), arg),
                c(
                    b(str("subscriber-ip-address"),
                        c(
                              ipv4addr
                        )
                    ),
                    b(str("subscriber-ipv6-address"),
                        c(
                              ipv6prefix
                        )
                    )
                )
            )
        )
    end

    rule(:jsscd_access_profile_type) do
        c(
            arg
        )
    end

    rule(:jsscd_authentication_type) do
        c(
            b(str("password"),
              unreadable
            ),
            b(str("username-include"),
                c(
                    a(str("delimiter"), arg),
                    a(str("domain-name"), arg),
                    a(str("user-prefix"), arg),
                    str("interface"),
                    str("logical-system-name"),
                    str("routing-instance-name"),
                    str("vlan-tags")
                )
            )
        )
    end

    rule(:jsscd_dynamic_profile_type) do
        ca(
            b(str("aggregate-clients"),
                c(
                    c(
                      str("merge"),
                      str("replace")
                    )
                )
            )
        )
    end

    rule(:jsscd_group_type) do
      b(arg.as(:arg),
        c(
            b(str("service-profile"),
              jsscd_service_profile_type
            ),
            b(str("access-profile"),
              jsscd_access_profile_type
            ),
            b(str("dynamic-profile"),
              jsscd_dynamic_profile_type
            ),
            b(str("authentication"),
              jsscd_authentication_type
            ),
            b(a(str("interface"), arg),
                sc(
                    b(str("upto"),
                      interface_unit
                    ),
                    str("exclude")
                )
            ).as(:oneline),
            str("auto-login")
        )
      )
    end

    rule(:jsscd_service_profile_type) do
        c(
              arg
        )
    end

    rule(:juniper_mobile_diameter) do
        c(
            b(str("traceoptions"),
              diameter_traceoptions
            ),
            b(str("origin"),
                c(
                    a(str("realm"), arg),
                    a(str("host"), arg)
                )
            ),
            a(str("vendor-id"), arg),
            a(str("firmware-revision"), arg),
            a(str("product-name"), arg),
            b(a(str("network-element"), arg),
                c(
                    b(str("function"),
                      (str("pcc-gx") | str("dcca-gy"))
                    ),
                    b(a(str("peer"), arg),
                        c(
                            a(str("priority"), arg),
                            a(str("timeout"), arg)
                        )
                    )
                )
            ),
            b(a(str("transport"), arg),
                c(
                    b(str("address"),
                      ipaddr
                    ),
                    c(
                      b(str("logical-system"),
                          sc(
                              arg,
                              a(str("routing-instance"), arg)
                          )
                      ).as(:oneline),
                      a(str("routing-instance"), arg)
                    )
                )
            ),
            b(a(str("peer"), arg),
                c(
                    b(str("address"),
                      ipaddr
                    ),
                    b(str("connect-actively"),
                        c(
                            a(str("transport"), arg),
                            a(str("port"), arg),
                            a(str("capabilities-exchange-timeout"), arg),
                            a(str("repeat-timeout"), arg),
                            a(str("retry-timeout"), arg),
                            a(str("timeout"), arg)
                        )
                    ),
                    b(str("incoming-queue"),
                        c(
                            a(str("size"), arg)
                        )
                    ),
                    b(str("outgoing-queue"),
                        c(
                            a(str("size"), arg),
                            a(str("low-watermark"), arg),
                            a(str("high-watermark"), arg)
                        )
                    ),
                    a(str("watchdog-timeout"), arg),
                    a(str("connection-timeout"), arg),
                    a(str("connection-repeat-timeout"), arg),
                    a(str("capabilities-exchange-timeout"), arg),
                    a(str("disconnect-peer-timeout"), arg),
                    a(str("connection-retry-timeout"), arg),
                    a(str("origin-host-prefix"), arg)
                )
            ),
            b(str("applications"),
                c(
                    b(str("pcc-gx"),
                        c(
                            a(str("maximum-pending-requests"), arg)
                        )
                    ),
                    b(str("dcca-gy"),
                        c(
                            a(str("maximum-pending-requests"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:diameter_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("send") | str("send-detail") | str("receive") | str("receive-detail") | str("timeout") | str("state") | str("all"))).as(:oneline),
            a(str("peer"), arg)
        )
    end

    rule(:juniper_monitoring_options) do
      b(arg.as(:arg),
        c(
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            b(str("input"),
                              monitoring_input_type
                            ),
                            b(str("output"),
                              monitoring_output_type
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:juniper_multicast_snooping_options) do
        c(
            b(str("options"),
                c(
                    b(str("syslog"),
                        c(
                            b(str("level"),
                                sc(
                                    str("emergency"),
                                    str("alert"),
                                    str("critical"),
                                    str("error"),
                                    str("warning"),
                                    str("notice"),
                                    str("info"),
                                    str("debug")
                                )
                            ).as(:oneline),
                            b(str("upto"),
                              (str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("debug"))
                            ),
                            a(str("mark"), arg)
                        )
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("parse") | str("config-internal") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("forwarding-cache"),
                c(
                    b(str("threshold"),
                        c(
                            a(str("suppress"), arg),
                            a(str("reuse"), arg)
                        )
                    )
                )
            ),
            b(str("flood-groups"),
              ipaddr
            ),
            b(str("host-outbound-traffic"),
                c(
                    a(str("forwarding-class"), arg),
                    a(str("dot1p"), arg)
                )
            ),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-duration"), arg)
                )
            ),
            str("ignore-stp-topology-change"),
            b(str("multichassis-lag-replicate-state"),
                c(
                    str("suppress-report")
                )
            ),
            a(str("nexthop-hold-time"), arg)
        )
    end

    rule(:juniper_next_hop_group_options) do
      b(arg.as(:arg),
        c(
            b(str("group-type"),
              (str("inet6") | str("layer-2") | str("inet"))
            ),
            b(str("interface"),
              next_hop_group_intf_type
            ),
            b(str("next-hop-subgroup"),
              juniper_next_hop_subgroup_options
            )
        )
      )
    end

    rule(:juniper_next_hop_subgroup_options) do
      b(arg.as(:arg),
        c(
            b(str("interface"),
              next_hop_subgroup_intf_type
            )
        )
      )
    end

    rule(:juniper_packet_accounting_options) do
      b(arg.as(:arg),
        c(
            b(str("output"),
              packet_accounting_output_type
            )
        )
      )
    end

    rule(:juniper_packet_capture_options) do
        c(
              (str("disable")),
            b(str("file"),
                sc(
                    arg,
                    a(str("files"), arg),
                    a(str("size"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            a(str("maximum-capture-size"), arg)
        )
    end

    rule(:juniper_pic_services_logging_options) do
        c(
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("init") | str("bookkeeping") | str("connections") | str("charging") | str("flow-collector") | str("all"))).as(:oneline)
                )
            )
        )
    end

    rule(:juniper_policy_options) do
        c(
            b(str("satellite-policies"),
              satellite_policy_options
            ),
            b(a(str("prefix-list"), arg),
                c(
                      a(str("apply-path"), quote | arg),
                      prefix_list_items
                )
            ),
            b(a(str("mac-list"), arg),
                c(
                      mac_addr_list_items
                )
            ),
            b(a(str("vsi-policy"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("vsi-manager"),
                                s(
                                        arg,
                                  a(str("vsi-type"), arg),
                                  a(str("vsi-version"), arg),
                                  a(str("vsi-instance"), arg)
                                )
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            a(str("filter"), arg)
                        )
                    )
                )
            ),
            str("skip-then-actions"),
            b(a(str("route-filter-list"), arg),
                c(
                      route_filter_list_items
                )
            ),
            b(a(str("source-address-filter-list"), arg),
                c(
                      source_address_filter_list_items
                )
            ),
            b(a(str("policy-statement"), arg),
                c(
                    b(str("defaults"),
                        c(
                            b(str("route-filter"),
                                sc(
                                    c(
                                      str("no-walkup"),
                                      str("walkup")
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("term"), arg),
                        c(
                            b(str("from"),
                                c(
                                    a(str("instance"), arg),
                                    str("instance-any"),
                                    a(str("instance-list"), arg),
                                    b(str("family"),
                                      (str("inet6") | str("inet-vpn") | str("inet") | str("inet6-vpn") | str("iso-vpn") | str("iso") | str("evpn") | str("inet-mvpn") | str("inet6-mvpn") | str("inet-mdt") | str("route-target") | str("traffic-engineering"))
                                    ),
                                    b(str("protocol"),
                                      (str("aggregate") | str("bgp") | str("direct") | str("dvmrp") | str("isis") | str("esis") | str("l-isis") | str("l2circuit") | str("l2vpn") | str("local") | str("ospf3") | str("ospf2") | str("ospf") | str("l-ospf") | str("pim") | str("rip") | str("ripng") | str("static") | str("arp") | str("frr") | str("mpls") | str("ldp") | str("rsvp") | str("msdp") | str("route-target") | str("access") | str("access-internal") | str("anchor") | str("bgp-static") | str("vpls") | str("evpn") | str("spring-te") | str("bgp-ls-epe") | str("rift") | str("l2-learned-host-routing"))
                                    ),
                                    a(str("rib"), arg),
                                    b(str("neighbor"),
                                      ipaddr
                                    ),
                                    b(str("next-hop"),
                                      ipaddr
                                    ),
                                    b(str("interface"),
                                      ipaddr_or_interface
                                    ),
                                    b(str("area"),
                                      areaid
                                    ),
                                    a(str("as-path"), arg),
                                    a(str("as-path-group"), arg),
                                    b(str("origin"),
                                      (str("igp") | str("egp") | str("incomplete"))
                                    ),
                                    a(str("community"), arg),
                                    a(str("level"), arg),
                                    b(str("external"),
                                        c(
                                            a(str("type"), arg)
                                        )
                                    ),
                                    b(str("validation-database"),
                                      (str("valid") | str("invalid") | str("unknown"))
                                    ),
                                    a(str("metric"), arg),
                                    a(str("metric2"), arg),
                                    a(str("metric3"), arg),
                                    a(str("metric4"), arg),
                                    a(str("tag"), arg),
                                    a(str("tag2"), arg),
                                    a(str("preference"), arg),
                                    a(str("preference2"), arg),
                                    a(str("color"), arg),
                                    a(str("color2"), arg),
                                    a(str("local-preference"), arg),
                                    b(str("policy"),
                                      policy_algebra
                                    ),
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg)
                                    ),
                                    b(a(str("route-filter"), arg),
                                      control_route_filter_type
                                    ).as(:oneline),
                                    b(a(str("source-adress-filter"), arg),
                                      control_source_address_filter_type
                                    ).as(:oneline),
                                    b(str("prefix-list"),
                                      control_prefix_list_type
                                    ),
                                    b(str("prefix-list-filter"),
                                      control_prefix_list_filter_type
                                    ),
                                    b(str("rtf-prefix-list"),
                                      control_rtf_prefix_list_type
                                    ),
                                    b(str("route-filter-list"),
                                      control_route_filter_list_type
                                    ),
                                    b(str("source-address-filter-list"),
                                      control_source_address_filter_list_type
                                    ),
                                    b(str("multicast-scope"),
                                        sc(
                                            c(
                                              str("node-local"),
                                              str("link-local"),
                                              str("site-local"),
                                              str("organization-local"),
                                              str("global"),
                                                arg
                                            ),
                                            c(
                                              str("orhigher"),
                                              str("orlower")
                                            )
                                        )
                                    ).as(:oneline),
                                    str("aggregate-contributor"),
                                    b(str("state"),
                                      (str("active") | str("inactive"))
                                    ),
                                    b(str("route-type"),
                                      (str("internal") | str("external"))
                                    ),
                                    a(str("nlri-route-type"), arg),
                                    b(str("next-hop-type"),
                                      (str("merged"))
                                    ),
                                    a(str("condition"), arg),
                                    b(str("community-count"),
                                      community_count_type
                                    ),
                                    b(str("as-path-unique-count"),
                                      as_path_unique_count_type
                                    ),
                                    b(str("as-path-calc-length"),
                                      as_path_calc_length_type
                                    ),
                                    b(str("traffic-engineering"),
                                        c(
                                            b(str("protocol"),
                                              (str("direct") | str("ospf") | str("isis-level-1") | str("isis-level-2") | str("static") | str("unknown"))
                                            ),
                                            b(str("node"),
                                                c(
                                                    a(str("as"), arg),
                                                    b(str("node-type"),
                                                      (str("router") | str("pseudo-node"))
                                                    ),
                                                    b(str("router-id"),
                                                      ipprefix
                                                    ),
                                                    b(str("sys-id"),
                                                      sysid
                                                    )
                                                )
                                            ),
                                            b(str("ipv4-prefix"),
                                                c(
                                                    a(str("as"), arg),
                                                    b(str("router-id"),
                                                      ipprefix
                                                    ),
                                                    b(str("prefix"),
                                                      ipprefix
                                                    ),
                                                    b(str("sys-id"),
                                                      sysid
                                                    )
                                                )
                                            ),
                                            b(str("link"),
                                                c(
                                                    b(str("from"),
                                                        c(
                                                            a(str("as"), arg),
                                                            b(str("router-id"),
                                                              ipprefix
                                                            ),
                                                            b(str("sys-id"),
                                                              sysid
                                                            ),
                                                            b(str("node-type"),
                                                              (str("router") | str("pseudo-node"))
                                                            ),
                                                            b(str("link-address"),
                                                              ipprefix
                                                            )
                                                        )
                                                    ),
                                                    b(str("to"),
                                                        c(
                                                            a(str("as"), arg),
                                                            b(str("router-id"),
                                                              ipprefix
                                                            ),
                                                            b(str("sys-id"),
                                                              sysid
                                                            ),
                                                            b(str("node-type"),
                                                              (str("router") | str("pseudo-node"))
                                                            ),
                                                            b(str("link-address"),
                                                              ipprefix
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    a(str("route-distinguisher"), arg)
                                )
                            ),
                            b(str("to"),
                                c(
                                    a(str("instance"), arg),
                                    str("instance-any"),
                                    a(str("instance-list"), arg),
                                    b(str("family"),
                                      (str("inet6") | str("inet-vpn") | str("inet") | str("inet6-vpn") | str("iso-vpn") | str("iso") | str("evpn") | str("inet-mvpn") | str("inet6-mvpn") | str("inet-mdt") | str("route-target") | str("traffic-engineering"))
                                    ),
                                    b(str("protocol"),
                                      (str("aggregate") | str("bgp") | str("direct") | str("dvmrp") | str("isis") | str("esis") | str("l-isis") | str("l2circuit") | str("l2vpn") | str("local") | str("ospf3") | str("ospf2") | str("ospf") | str("l-ospf") | str("pim") | str("rip") | str("ripng") | str("static") | str("arp") | str("frr") | str("mpls") | str("ldp") | str("rsvp") | str("msdp") | str("route-target") | str("access") | str("access-internal") | str("anchor") | str("bgp-static") | str("vpls") | str("evpn") | str("spring-te") | str("bgp-ls-epe") | str("rift") | str("l2-learned-host-routing"))
                                    ),
                                    a(str("rib"), arg),
                                    b(str("neighbor"),
                                      ipaddr
                                    ),
                                    b(str("next-hop"),
                                      ipaddr
                                    ),
                                    b(str("interface"),
                                      ipaddr_or_interface
                                    ),
                                    b(str("area"),
                                      areaid
                                    ),
                                    a(str("as-path"), arg),
                                    a(str("as-path-group"), arg),
                                    b(str("origin"),
                                      (str("igp") | str("egp") | str("incomplete"))
                                    ),
                                    a(str("community"), arg),
                                    a(str("level"), arg),
                                    b(str("external"),
                                        c(
                                            a(str("type"), arg)
                                        )
                                    ),
                                    b(str("validation-database"),
                                      (str("valid") | str("invalid") | str("unknown"))
                                    ),
                                    a(str("metric"), arg),
                                    a(str("metric2"), arg),
                                    a(str("metric3"), arg),
                                    a(str("metric4"), arg),
                                    a(str("tag"), arg),
                                    a(str("tag2"), arg),
                                    a(str("preference"), arg),
                                    a(str("preference2"), arg),
                                    a(str("color"), arg),
                                    a(str("color2"), arg),
                                    a(str("local-preference"), arg),
                                    b(str("policy"),
                                      policy_algebra
                                    ),
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg)
                                    )
                                )
                            ),
                            b(str("then"),
                                c(
                                    b(str("metric"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg),
                                              b(str("igp"),
                                                  sc(
                                                      arg
                                                  )
                                              ).as(:oneline),
                                              b(str("minimum-igp"),
                                                  sc(
                                                      arg
                                                  )
                                              ).as(:oneline),
                                              b(str("expression"),
                                                metric_expression_type
                                              ),
                                              str("aigp"),
                                              b(str("effective-aigp"),
                                                  sc(
                                                      arg
                                                  )
                                              ).as(:oneline),
                                              b(str("minimum-effective-aigp"),
                                                  sc(
                                                      arg
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    ),
                                    b(str("metric2"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("metric3"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("metric4"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("tag"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("tag2"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("preference"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("preference2"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("color"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("color2"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("local-preference"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg)
                                            )
                                        )
                                    ),
                                    b(str("priority"),
                                      (str("high") | str("medium") | str("low"))
                                    ),
                                    b(str("prefix-segment"),
                                        sc(
                                            a(str("index"), arg),
                                            str("node-segment")
                                        )
                                    ).as(:oneline),
                                    b(str("label-allocation"),
                                      (str("per-table") | str("per-nexthop") | str("per-table-localize"))
                                    ),
                                    b(str("add-path"),
                                        sc(
                                            a(str("send-count"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("validation-state"),
                                      (str("valid") | str("invalid") | str("unknown"))
                                    ),
                                    b(str("origin"),
                                      (str("igp") | str("egp") | str("incomplete"))
                                    ),
                                    b(str("aigp-originate"),
                                        sc(
                                            a(str("distance"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("aigp-adjust"),
                                        sc(
                                            c(
                                              str("add"),
                                              str("subtract"),
                                              str("multiply"),
                                              str("divide")
                                            ),
                                            ca(
                                              str("distance-to-protocol-nexthop")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("community"),
                                        s(
                                          c(
                                            a(str("="), arg),
                                            a(str("set"), arg),
                                            a(str("+"), arg),
                                            a(str("add"), arg),
                                            a(str("-"), arg),
                                            a(str("delete"), arg)
                                          ),
                                                arg
                                        )
                                    ).as(:oneline),
                                    a(str("damping"), arg),
                                    str("aggregate-bandwidth"),
                                    a(str("limit-bandwidth"), arg),
                                    str("no-entropy-label-capability"),
                                    a(str("as-path-prepend"), quote | arg),
                                    b(str("as-path-expand"),
                                        sc(
                                            c(
                                              b(str("last-as"),
                                                  sc(
                                                      a(str("count"), arg)
                                                  )
                                              ).as(:oneline),
                                              arg
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("next-hop"),
                                        sc(
                                            c(
                                              str("self"),
                                              str("peer-address"),
                                              str("reject"),
                                              str("discard"),
                                              a(str("next-table"), arg),
                                                ipaddr
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("install-nexthop"),
                                        sc(
                                            c(
                                              str("strict"),
                                              str("strict-named-lsp")
                                            ),
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg),
                                              str("non-lsp-nexthop"),
                                              str("non-labelled-nexthop")
                                            ),
                                            b(str("except"),
                                                c(
                                                    c(
                                                      a(str("lsp"), arg),
                                                      a(str("lsp-regex"), arg),
                                                      a(str("static-lsp"), arg),
                                                      a(str("static-lsp-regex"), arg),
                                                      str("non-lsp-nexthop"),
                                                      str("non-labelled-nexthop")
                                                    ),
                                                    b(str("fallback"),
                                                        c(
                                                            c(
                                                              a(str("lsp"), arg),
                                                              a(str("lsp-regex"), arg),
                                                              a(str("static-lsp"), arg),
                                                              a(str("static-lsp-regex"), arg),
                                                              str("non-lsp-nexthop"),
                                                              str("non-labelled-nexthop")
                                                            ),
                                                            b(str("except"),
                                                                c(
                                                                    c(
                                                                      a(str("lsp"), arg),
                                                                      a(str("lsp-regex"), arg),
                                                                      a(str("static-lsp"), arg),
                                                                      a(str("static-lsp-regex"), arg),
                                                                      str("non-lsp-nexthop"),
                                                                      str("non-labelled-nexthop")
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("fallback"),
                                                c(
                                                    c(
                                                      a(str("lsp"), arg),
                                                      a(str("lsp-regex"), arg),
                                                      a(str("static-lsp"), arg),
                                                      a(str("static-lsp-regex"), arg),
                                                      str("non-lsp-nexthop"),
                                                      str("non-labelled-nexthop")
                                                    ),
                                                    b(str("except"),
                                                        c(
                                                            c(
                                                              a(str("lsp"), arg),
                                                              a(str("lsp-regex"), arg),
                                                              a(str("static-lsp"), arg),
                                                              a(str("static-lsp-regex"), arg),
                                                              str("non-lsp-nexthop"),
                                                              str("non-labelled-nexthop")
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ).as(:oneline),
                                    str("trace"),
                                    b(str("external"),
                                        c(
                                            a(str("type"), arg),
                                            str("nssa-only")
                                        )
                                    ),
                                    b(str("load-balance"),
                                        sc(
                                            c(
                                              str("per-packet"),
                                              str("random"),
                                              str("per-prefix"),
                                              str("consistent-hash"),
                                              str("source-ip-only"),
                                              str("destination-ip-only")
                                            )
                                        )
                                    ).as(:oneline),
                                    str("no-route-localize"),
                                    str("install-to-fib"),
                                    str("no-install-to-fib"),
                                    str("analyze"),
                                    a(str("class"), arg),
                                    a(str("destination-class"), arg),
                                    a(str("source-class"), arg),
                                    a(str("forwarding-class"), arg),
                                    b(str("map-to-interface"),
                                        sc(
                                            c(
                                              str("self"),
                                                interface_name
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("ssm-source"),
                                      ipaddr
                                    ),
                                    b(str("p2mp-lsp-root"),
                                        c(
                                            b(str("address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    a(str("cos-next-hop-map"), arg),
                                    a(str("dynamic-tunnel-attributes"), arg),
                                    str("selected-mldp-egress"),
                                    str("mhop-bfd-port"),
                                    str("no-backup"),
                                    b(str("default-action"),
                                      (str("accept") | str("reject"))
                                    ),
                                    b(str("next"),
                                      (str("policy") | str("term"))
                                    ),
                                    c(
                                      str("accept"),
                                      str("reject")
                                    ),
                                    b(str("bgp-output-queue-priority"),
                                        sc(
                                            c(
                                              a(str("priority"), arg),
                                              str("expedited")
                                            )
                                        )
                                    ).as(:oneline),
                                    str("multipath-resolve"),
                                    a(str("sr-te-template"), arg),
                                    str("label-allocation-fallback-reject"),
                                    a(str("resolution-map"), arg)
                                )
                            )
                        )
                    ),
                    b(str("from"),
                        c(
                            a(str("instance"), arg),
                            str("instance-any"),
                            a(str("instance-list"), arg),
                            b(str("family"),
                              (str("inet6") | str("inet-vpn") | str("inet") | str("inet6-vpn") | str("iso-vpn") | str("iso") | str("evpn") | str("inet-mvpn") | str("inet6-mvpn") | str("inet-mdt") | str("route-target") | str("traffic-engineering"))
                            ),
                            b(str("protocol"),
                              (str("aggregate") | str("bgp") | str("direct") | str("dvmrp") | str("isis") | str("esis") | str("l-isis") | str("l2circuit") | str("l2vpn") | str("local") | str("ospf3") | str("ospf2") | str("ospf") | str("l-ospf") | str("pim") | str("rip") | str("ripng") | str("static") | str("arp") | str("frr") | str("mpls") | str("ldp") | str("rsvp") | str("msdp") | str("route-target") | str("access") | str("access-internal") | str("anchor") | str("bgp-static") | str("vpls") | str("evpn") | str("spring-te") | str("bgp-ls-epe") | str("rift") | str("l2-learned-host-routing"))
                            ),
                            a(str("rib"), arg),
                            b(str("neighbor"),
                              ipaddr
                            ),
                            b(str("next-hop"),
                              ipaddr
                            ),
                            b(str("interface"),
                              ipaddr_or_interface
                            ),
                            b(str("area"),
                              areaid
                            ),
                            a(str("as-path"), arg),
                            a(str("as-path-group"), arg),
                            b(str("origin"),
                              (str("igp") | str("egp") | str("incomplete"))
                            ),
                            a(str("community"), arg),
                            a(str("level"), arg),
                            b(str("external"),
                                c(
                                    a(str("type"), arg)
                                )
                            ),
                            b(str("validation-database"),
                              (str("valid") | str("invalid") | str("unknown"))
                            ),
                            a(str("metric"), arg),
                            a(str("metric2"), arg),
                            a(str("metric3"), arg),
                            a(str("metric4"), arg),
                            a(str("tag"), arg),
                            a(str("tag2"), arg),
                            a(str("preference"), arg),
                            a(str("preference2"), arg),
                            a(str("color"), arg),
                            a(str("color2"), arg),
                            a(str("local-preference"), arg),
                            b(str("policy"),
                              policy_algebra
                            ),
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg)
                            ),
                            b(a(str("route-filter"), arg),
                              control_route_filter_type
                            ).as(:oneline),
                            b(a(str("source-adress-filter"), arg),
                              control_source_address_filter_type
                            ).as(:oneline),
                            b(str("prefix-list"),
                              control_prefix_list_type
                            ),
                            b(str("prefix-list-filter"),
                              control_prefix_list_filter_type
                            ),
                            b(str("rtf-prefix-list"),
                              control_rtf_prefix_list_type
                            ),
                            b(str("route-filter-list"),
                              control_route_filter_list_type
                            ),
                            b(str("source-address-filter-list"),
                              control_source_address_filter_list_type
                            ),
                            b(str("multicast-scope"),
                                sc(
                                    c(
                                      str("node-local"),
                                      str("link-local"),
                                      str("site-local"),
                                      str("organization-local"),
                                      str("global"),
                                        arg
                                    ),
                                    c(
                                      str("orhigher"),
                                      str("orlower")
                                    )
                                )
                            ).as(:oneline),
                            str("aggregate-contributor"),
                            b(str("state"),
                              (str("active") | str("inactive"))
                            ),
                            b(str("route-type"),
                              (str("internal") | str("external"))
                            ),
                            a(str("nlri-route-type"), arg),
                            b(str("next-hop-type"),
                              (str("merged"))
                            ),
                            a(str("condition"), arg),
                            b(str("community-count"),
                              community_count_type
                            ),
                            b(str("as-path-unique-count"),
                              as_path_unique_count_type
                            ),
                            b(str("as-path-calc-length"),
                              as_path_calc_length_type
                            ),
                            b(str("traffic-engineering"),
                                c(
                                    b(str("protocol"),
                                      (str("direct") | str("ospf") | str("isis-level-1") | str("isis-level-2") | str("static") | str("unknown"))
                                    ),
                                    b(str("node"),
                                        c(
                                            a(str("as"), arg),
                                            b(str("node-type"),
                                              (str("router") | str("pseudo-node"))
                                            ),
                                            b(str("router-id"),
                                              ipprefix
                                            ),
                                            b(str("sys-id"),
                                              sysid
                                            )
                                        )
                                    ),
                                    b(str("ipv4-prefix"),
                                        c(
                                            a(str("as"), arg),
                                            b(str("router-id"),
                                              ipprefix
                                            ),
                                            b(str("prefix"),
                                              ipprefix
                                            ),
                                            b(str("sys-id"),
                                              sysid
                                            )
                                        )
                                    ),
                                    b(str("link"),
                                        c(
                                            b(str("from"),
                                                c(
                                                    a(str("as"), arg),
                                                    b(str("router-id"),
                                                      ipprefix
                                                    ),
                                                    b(str("sys-id"),
                                                      sysid
                                                    ),
                                                    b(str("node-type"),
                                                      (str("router") | str("pseudo-node"))
                                                    ),
                                                    b(str("link-address"),
                                                      ipprefix
                                                    )
                                                )
                                            ),
                                            b(str("to"),
                                                c(
                                                    a(str("as"), arg),
                                                    b(str("router-id"),
                                                      ipprefix
                                                    ),
                                                    b(str("sys-id"),
                                                      sysid
                                                    ),
                                                    b(str("node-type"),
                                                      (str("router") | str("pseudo-node"))
                                                    ),
                                                    b(str("link-address"),
                                                      ipprefix
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("route-distinguisher"), arg)
                        )
                    ),
                    b(str("to"),
                        c(
                            a(str("instance"), arg),
                            str("instance-any"),
                            a(str("instance-list"), arg),
                            b(str("family"),
                              (str("inet6") | str("inet-vpn") | str("inet") | str("inet6-vpn") | str("iso-vpn") | str("iso") | str("evpn") | str("inet-mvpn") | str("inet6-mvpn") | str("inet-mdt") | str("route-target") | str("traffic-engineering"))
                            ),
                            b(str("protocol"),
                              (str("aggregate") | str("bgp") | str("direct") | str("dvmrp") | str("isis") | str("esis") | str("l-isis") | str("l2circuit") | str("l2vpn") | str("local") | str("ospf3") | str("ospf2") | str("ospf") | str("l-ospf") | str("pim") | str("rip") | str("ripng") | str("static") | str("arp") | str("frr") | str("mpls") | str("ldp") | str("rsvp") | str("msdp") | str("route-target") | str("access") | str("access-internal") | str("anchor") | str("bgp-static") | str("vpls") | str("evpn") | str("spring-te") | str("bgp-ls-epe") | str("rift") | str("l2-learned-host-routing"))
                            ),
                            a(str("rib"), arg),
                            b(str("neighbor"),
                              ipaddr
                            ),
                            b(str("next-hop"),
                              ipaddr
                            ),
                            b(str("interface"),
                              ipaddr_or_interface
                            ),
                            b(str("area"),
                              areaid
                            ),
                            a(str("as-path"), arg),
                            a(str("as-path-group"), arg),
                            b(str("origin"),
                              (str("igp") | str("egp") | str("incomplete"))
                            ),
                            a(str("community"), arg),
                            a(str("level"), arg),
                            b(str("external"),
                                c(
                                    a(str("type"), arg)
                                )
                            ),
                            b(str("validation-database"),
                              (str("valid") | str("invalid") | str("unknown"))
                            ),
                            a(str("metric"), arg),
                            a(str("metric2"), arg),
                            a(str("metric3"), arg),
                            a(str("metric4"), arg),
                            a(str("tag"), arg),
                            a(str("tag2"), arg),
                            a(str("preference"), arg),
                            a(str("preference2"), arg),
                            a(str("color"), arg),
                            a(str("color2"), arg),
                            a(str("local-preference"), arg),
                            b(str("policy"),
                              policy_algebra
                            ),
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            b(str("metric"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg),
                                      b(str("igp"),
                                          sc(
                                              arg
                                          )
                                      ).as(:oneline),
                                      b(str("minimum-igp"),
                                          sc(
                                              arg
                                          )
                                      ).as(:oneline),
                                      b(str("expression"),
                                        metric_expression_type
                                      ),
                                      str("aigp"),
                                      b(str("effective-aigp"),
                                          sc(
                                              arg
                                          )
                                      ).as(:oneline),
                                      b(str("minimum-effective-aigp"),
                                          sc(
                                              arg
                                          )
                                      ).as(:oneline)
                                    )
                                )
                            ),
                            b(str("metric2"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("metric3"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("metric4"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("tag"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("tag2"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("preference"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("preference2"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("color"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("color2"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("local-preference"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg)
                                    )
                                )
                            ),
                            b(str("priority"),
                              (str("high") | str("medium") | str("low"))
                            ),
                            b(str("prefix-segment"),
                                sc(
                                    a(str("index"), arg),
                                    str("node-segment")
                                )
                            ).as(:oneline),
                            b(str("label-allocation"),
                              (str("per-table") | str("per-nexthop") | str("per-table-localize"))
                            ),
                            b(str("add-path"),
                                sc(
                                    a(str("send-count"), arg)
                                )
                            ).as(:oneline),
                            b(str("validation-state"),
                              (str("valid") | str("invalid") | str("unknown"))
                            ),
                            b(str("origin"),
                              (str("igp") | str("egp") | str("incomplete"))
                            ),
                            b(str("aigp-originate"),
                                sc(
                                    a(str("distance"), arg)
                                )
                            ).as(:oneline),
                            b(str("aigp-adjust"),
                                sc(
                                    c(
                                      str("add"),
                                      str("subtract"),
                                      str("multiply"),
                                      str("divide")
                                    ),
                                    ca(
                                      str("distance-to-protocol-nexthop")
                                    )
                                )
                            ).as(:oneline),
                            b(str("community"),
                                s(
                                  c(
                                    a(str("="), arg),
                                    a(str("set"), arg),
                                    a(str("+"), arg),
                                    a(str("add"), arg),
                                    a(str("-"), arg),
                                    a(str("delete"), arg)
                                  ),
                                        arg
                                )
                            ).as(:oneline),
                            a(str("damping"), arg),
                            str("aggregate-bandwidth"),
                            a(str("limit-bandwidth"), arg),
                            str("no-entropy-label-capability"),
                            a(str("as-path-prepend"), quote | arg),
                            b(str("as-path-expand"),
                                sc(
                                    c(
                                      b(str("last-as"),
                                          sc(
                                              a(str("count"), arg)
                                          )
                                      ).as(:oneline),
                                      arg
                                    )
                                )
                            ).as(:oneline),
                            b(str("next-hop"),
                                sc(
                                    c(
                                      str("self"),
                                      str("peer-address"),
                                      str("reject"),
                                      str("discard"),
                                      a(str("next-table"), arg),
                                        ipaddr
                                    )
                                )
                            ).as(:oneline),
                            b(str("install-nexthop"),
                                sc(
                                    c(
                                      str("strict"),
                                      str("strict-named-lsp")
                                    ),
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    ),
                                    b(str("except"),
                                        c(
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg),
                                              str("non-lsp-nexthop"),
                                              str("non-labelled-nexthop")
                                            ),
                                            b(str("fallback"),
                                                c(
                                                    c(
                                                      a(str("lsp"), arg),
                                                      a(str("lsp-regex"), arg),
                                                      a(str("static-lsp"), arg),
                                                      a(str("static-lsp-regex"), arg),
                                                      str("non-lsp-nexthop"),
                                                      str("non-labelled-nexthop")
                                                    ),
                                                    b(str("except"),
                                                        c(
                                                            c(
                                                              a(str("lsp"), arg),
                                                              a(str("lsp-regex"), arg),
                                                              a(str("static-lsp"), arg),
                                                              a(str("static-lsp-regex"), arg),
                                                              str("non-lsp-nexthop"),
                                                              str("non-labelled-nexthop")
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("fallback"),
                                        c(
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg),
                                              str("non-lsp-nexthop"),
                                              str("non-labelled-nexthop")
                                            ),
                                            b(str("except"),
                                                c(
                                                    c(
                                                      a(str("lsp"), arg),
                                                      a(str("lsp-regex"), arg),
                                                      a(str("static-lsp"), arg),
                                                      a(str("static-lsp-regex"), arg),
                                                      str("non-lsp-nexthop"),
                                                      str("non-labelled-nexthop")
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ).as(:oneline),
                            str("trace"),
                            b(str("external"),
                                c(
                                    a(str("type"), arg),
                                    str("nssa-only")
                                )
                            ),
                            b(str("load-balance"),
                                sc(
                                    c(
                                      str("per-packet"),
                                      str("random"),
                                      str("per-prefix"),
                                      str("consistent-hash"),
                                      str("source-ip-only"),
                                      str("destination-ip-only")
                                    )
                                )
                            ).as(:oneline),
                            str("no-route-localize"),
                            str("install-to-fib"),
                            str("no-install-to-fib"),
                            str("analyze"),
                            a(str("class"), arg),
                            a(str("destination-class"), arg),
                            a(str("source-class"), arg),
                            a(str("forwarding-class"), arg),
                            b(str("map-to-interface"),
                                sc(
                                    c(
                                      str("self"),
                                        interface_name
                                    )
                                )
                            ).as(:oneline),
                            b(str("ssm-source"),
                              ipaddr
                            ),
                            b(str("p2mp-lsp-root"),
                                c(
                                    b(str("address"),
                                      ipv4addr
                                    )
                                )
                            ),
                            a(str("cos-next-hop-map"), arg),
                            a(str("dynamic-tunnel-attributes"), arg),
                            str("selected-mldp-egress"),
                            str("mhop-bfd-port"),
                            str("no-backup"),
                            b(str("default-action"),
                              (str("accept") | str("reject"))
                            ),
                            b(str("next"),
                              (str("policy") | str("term"))
                            ),
                            c(
                              str("accept"),
                              str("reject")
                            ),
                            b(str("bgp-output-queue-priority"),
                                sc(
                                    c(
                                      a(str("priority"), arg),
                                      str("expedited")
                                    )
                                )
                            ).as(:oneline),
                            str("multipath-resolve"),
                            a(str("sr-te-template"), arg),
                            str("label-allocation-fallback-reject"),
                            a(str("resolution-map"), arg)
                        )
                    )
                )
            ),
            b(str("defaults"),
                c(
                    b(str("route-filter"),
                        sc(
                            str("walkup")
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("community"), arg),
                c(
                    str("invert-match"),
                    a(str("members"), any)
                )
            ),
            b(a(str("route-distinguisher"), arg),
                c(
                    a(str("members"), any)
                )
            ),
            b(a(str("as-path"), arg),
              c(
                quote | arg
                )
            ),
            b(a(str("as-path-group"), arg),
                c(
                    b(a(str("as-path"), arg),
                        sc(
                            arg
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("damping"), arg),
                c(
                      (str("disable")),
                    a(str("half-life"), arg),
                    a(str("reuse"), arg),
                    a(str("suppress"), arg),
                    a(str("max-suppress"), arg)
                )
            ),
            b(a(str("condition"), arg),
                c(
                    c(
                      b(str("route-active-on"),
                        (str("node0") | str("node1"))
                      ),
                      b(str("if-route-exists"),
                          c(
                              b(str("address-family"),
                                  c(
                                      c(
                                        b(str("inet"),
                                            c(
                                                a(str("table"), arg),
                                                  ipprefix
                                            )
                                        ),
                                        b(str("ccc"),
                                            c(
                                                  interface_name,
                                                a(str("table"), arg),
                                                str("standby"),
                                                a(str("peer-unit"), arg)
                                            )
                                        )
                                      )
                                  )
                              ),
                              a(str("table"), arg),
                                ipprefix
                          )
                      )
                    )
                )
            ),
            b(a(str("rtf-prefix-list"), arg),
                c(
                      rtf_prefix_list_items
                )
            ),
            b(a(str("resolution-map"), arg),
                c(
                    b(str("mode"),
                      (str("ip-color") | str("color-only"))
                    )
                )
            ),
            b(str("application-maps"),
              application_map_object
            ),
            b(a(str("redundancy-policy"), arg),
                c(
                    a(str("redundancy-events"), arg),
                    b(str("then"),
                      srd_ev_action_object
                    )
                )
            )
        )
    end

    rule(:application_map_object) do
      b(arg.as(:arg),
        c(
            b(a(str("application"), arg),
                sc(
                    a(str("code-points"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:as_path_calc_length_type) do
      b(arg.as(:arg),
        c(
            c(
              str("equal"),
              str("orhigher"),
              str("orlower")
            )
        )
      ).as(:oneline)
    end

    rule(:as_path_unique_count_type) do
      b(arg.as(:arg),
        c(
            c(
              str("equal"),
              str("orhigher"),
              str("orlower")
            )
        )
      ).as(:oneline)
    end

    rule(:community_count_type) do
      b(arg.as(:arg),
        c(
            c(
              str("equal"),
              str("orhigher"),
              str("orlower")
            )
        )
      ).as(:oneline)
    end

    rule(:control_prefix_list_filter_type) do
        s(
                arg,
          c(
            str("exact"),
            str("longer"),
            str("orlonger")
          ),
          c(
            b(str("metric"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg),
                      b(str("igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("expression"),
                        metric_expression_type
                      ),
                      str("aigp"),
                      b(str("effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline)
                    )
                )
            ),
            b(str("metric2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric3"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric4"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("local-preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("priority"),
              (str("high") | str("medium") | str("low"))
            ),
            b(str("prefix-segment"),
                sc(
                    a(str("index"), arg),
                    str("node-segment")
                )
            ).as(:oneline),
            b(str("label-allocation"),
              (str("per-table") | str("per-nexthop") | str("per-table-localize"))
            ),
            b(str("add-path"),
                sc(
                    a(str("send-count"), arg)
                )
            ).as(:oneline),
            b(str("validation-state"),
              (str("valid") | str("invalid") | str("unknown"))
            ),
            b(str("origin"),
              (str("igp") | str("egp") | str("incomplete"))
            ),
            b(str("aigp-originate"),
                sc(
                    a(str("distance"), arg)
                )
            ).as(:oneline),
            b(str("aigp-adjust"),
                sc(
                    c(
                      str("add"),
                      str("subtract"),
                      str("multiply"),
                      str("divide")
                    ),
                    ca(
                      str("distance-to-protocol-nexthop")
                    )
                )
            ).as(:oneline),
            b(str("community"),
                s(
                  c(
                    a(str("="), arg),
                    a(str("set"), arg),
                    a(str("+"), arg),
                    a(str("add"), arg),
                    a(str("-"), arg),
                    a(str("delete"), arg)
                  ),
                        arg
                )
            ).as(:oneline),
            a(str("damping"), arg),
            str("aggregate-bandwidth"),
            a(str("limit-bandwidth"), arg),
            str("no-entropy-label-capability"),
            a(str("as-path-prepend"), quote | arg),
            b(str("as-path-expand"),
                sc(
                    c(
                      b(str("last-as"),
                          sc(
                              a(str("count"), arg)
                          )
                      ).as(:oneline),
                      arg
                    )
                )
            ).as(:oneline),
            b(str("next-hop"),
                sc(
                    c(
                      str("self"),
                      str("peer-address"),
                      str("reject"),
                      str("discard"),
                      a(str("next-table"), arg),
                        ipaddr
                    )
                )
            ).as(:oneline),
            b(str("install-nexthop"),
                sc(
                    c(
                      str("strict"),
                      str("strict-named-lsp")
                    ),
                    c(
                      a(str("lsp"), arg),
                      a(str("lsp-regex"), arg),
                      a(str("static-lsp"), arg),
                      a(str("static-lsp-regex"), arg),
                      str("non-lsp-nexthop"),
                      str("non-labelled-nexthop")
                    ),
                    b(str("except"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("fallback"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    ),
                                    b(str("except"),
                                        c(
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg),
                                              str("non-lsp-nexthop"),
                                              str("non-labelled-nexthop")
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("fallback"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("except"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    )
                                )
                            )
                        )
                    )
                )
            ).as(:oneline),
            str("trace"),
            b(str("external"),
                c(
                    a(str("type"), arg),
                    str("nssa-only")
                )
            ),
            b(str("load-balance"),
                sc(
                    c(
                      str("per-packet"),
                      str("random"),
                      str("per-prefix"),
                      str("consistent-hash"),
                      str("source-ip-only"),
                      str("destination-ip-only")
                    )
                )
            ).as(:oneline),
            str("no-route-localize"),
            str("install-to-fib"),
            str("no-install-to-fib"),
            str("analyze"),
            a(str("class"), arg),
            a(str("destination-class"), arg),
            a(str("source-class"), arg),
            a(str("forwarding-class"), arg),
            b(str("map-to-interface"),
                sc(
                    c(
                      str("self"),
                        interface_name
                    )
                )
            ).as(:oneline),
            b(str("ssm-source"),
              ipaddr
            ),
            b(str("p2mp-lsp-root"),
                c(
                    b(str("address"),
                      ipv4addr
                    )
                )
            ),
            a(str("cos-next-hop-map"), arg),
            a(str("dynamic-tunnel-attributes"), arg),
            str("selected-mldp-egress"),
            str("mhop-bfd-port"),
            str("no-backup"),
            b(str("default-action"),
              (str("accept") | str("reject"))
            ),
            b(str("next"),
              (str("policy") | str("term"))
            ),
            c(
              str("accept"),
              str("reject")
            ),
            b(str("bgp-output-queue-priority"),
                sc(
                    c(
                      a(str("priority"), arg),
                      str("expedited")
                    )
                )
            ).as(:oneline),
            str("multipath-resolve"),
            a(str("sr-te-template"), arg),
            str("label-allocation-fallback-reject"),
            a(str("resolution-map"), arg)
          )
        )
    end

    rule(:control_prefix_list_type) do
      arg.as(:arg)
    end

    rule(:control_route_filter_list_type) do
      arg.as(:arg)
    end

    rule(:control_route_filter_type) do
        b(
          c(
            str("exact"),
            str("longer"),
            str("orlonger"),
            a(str("upto"), arg),
            a(str("through"), arg),
            a(str("prefix-length-range"), arg),
            a(str("address-mask"), arg)
          ),
          c(
            b(str("label"),
                sc(
                    c(
                      b(str("range"),
                          sc(
                              c(
                                arg
                              )
                          )
                      ).as(:oneline),
                        arg
                    )
                )
            ).as(:oneline),
            str("get-route-range"),
            b(str("metric"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg),
                      b(str("igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("expression"),
                        metric_expression_type
                      ),
                      str("aigp"),
                      b(str("effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline)
                    )
                )
            ),
            b(str("metric2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric3"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric4"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("local-preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("priority"),
              (str("high") | str("medium") | str("low"))
            ),
            b(str("prefix-segment"),
                sc(
                    a(str("index"), arg),
                    str("node-segment")
                )
            ).as(:oneline),
            b(str("label-allocation"),
              (str("per-table") | str("per-nexthop") | str("per-table-localize"))
            ),
            b(str("add-path"),
                sc(
                    a(str("send-count"), arg)
                )
            ).as(:oneline),
            b(str("validation-state"),
              (str("valid") | str("invalid") | str("unknown"))
            ),
            b(str("origin"),
              (str("igp") | str("egp") | str("incomplete"))
            ),
            b(str("aigp-originate"),
                sc(
                    a(str("distance"), arg)
                )
            ).as(:oneline),
            b(str("aigp-adjust"),
                sc(
                    c(
                      str("add"),
                      str("subtract"),
                      str("multiply"),
                      str("divide")
                    ),
                    ca(
                      str("distance-to-protocol-nexthop")
                    )
                )
            ).as(:oneline),
            b(str("community"),
                s(
                  c(
                    a(str("="), arg),
                    a(str("set"), arg),
                    a(str("+"), arg),
                    a(str("add"), arg),
                    a(str("-"), arg),
                    a(str("delete"), arg)
                  ),
                        arg
                )
            ).as(:oneline),
            a(str("damping"), arg),
            str("aggregate-bandwidth"),
            a(str("limit-bandwidth"), arg),
            str("no-entropy-label-capability"),
            a(str("as-path-prepend"), quote | arg),
            b(str("as-path-expand"),
                sc(
                    c(
                      b(str("last-as"),
                          sc(
                              a(str("count"), arg)
                          )
                      ).as(:oneline),
                      arg
                    )
                )
            ).as(:oneline),
            b(str("next-hop"),
                sc(
                    c(
                      str("self"),
                      str("peer-address"),
                      str("reject"),
                      str("discard"),
                      a(str("next-table"), arg),
                        ipaddr
                    )
                )
            ).as(:oneline),
            b(str("install-nexthop"),
                sc(
                    c(
                      str("strict"),
                      str("strict-named-lsp")
                    ),
                    c(
                      a(str("lsp"), arg),
                      a(str("lsp-regex"), arg),
                      a(str("static-lsp"), arg),
                      a(str("static-lsp-regex"), arg),
                      str("non-lsp-nexthop"),
                      str("non-labelled-nexthop")
                    ),
                    b(str("except"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("fallback"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    ),
                                    b(str("except"),
                                        c(
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg),
                                              str("non-lsp-nexthop"),
                                              str("non-labelled-nexthop")
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("fallback"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("except"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    )
                                )
                            )
                        )
                    )
                )
            ).as(:oneline),
            str("trace"),
            b(str("external"),
                c(
                    a(str("type"), arg),
                    str("nssa-only")
                )
            ),
            b(str("load-balance"),
                sc(
                    c(
                      str("per-packet"),
                      str("random"),
                      str("per-prefix"),
                      str("consistent-hash"),
                      str("source-ip-only"),
                      str("destination-ip-only")
                    )
                )
            ).as(:oneline),
            str("no-route-localize"),
            str("install-to-fib"),
            str("no-install-to-fib"),
            str("analyze"),
            a(str("class"), arg),
            a(str("destination-class"), arg),
            a(str("source-class"), arg),
            a(str("forwarding-class"), arg),
            b(str("map-to-interface"),
                sc(
                    c(
                      str("self"),
                        interface_name
                    )
                )
            ).as(:oneline),
            b(str("ssm-source"),
              ipaddr
            ),
            b(str("p2mp-lsp-root"),
                c(
                    b(str("address"),
                      ipv4addr
                    )
                )
            ),
            a(str("cos-next-hop-map"), arg),
            a(str("dynamic-tunnel-attributes"), arg),
            str("selected-mldp-egress"),
            str("mhop-bfd-port"),
            str("no-backup"),
            b(str("default-action"),
              (str("accept") | str("reject"))
            ),
            b(str("next"),
              (str("policy") | str("term"))
            ),
            c(
              str("accept"),
              str("reject")
            ),
            b(str("bgp-output-queue-priority"),
                sc(
                    c(
                      a(str("priority"), arg),
                      str("expedited")
                    )
                )
            ).as(:oneline),
            str("multipath-resolve"),
            a(str("sr-te-template"), arg),
            str("label-allocation-fallback-reject"),
            a(str("resolution-map"), arg)
          )
        )
    end

    rule(:control_rtf_prefix_list_type) do
      arg.as(:arg)
    end

    rule(:control_source_address_filter_list_type) do
      arg.as(:arg)
    end

    rule(:control_source_address_filter_type) do
        b(
          c(
            str("exact"),
            str("longer"),
            str("orlonger"),
            a(str("upto"), arg),
            a(str("through"), arg),
            a(str("prefix-length-range"), arg)
          ),
          c(
            b(str("metric"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg),
                      b(str("igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("expression"),
                        metric_expression_type
                      ),
                      str("aigp"),
                      b(str("effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline)
                    )
                )
            ),
            b(str("metric2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric3"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric4"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("local-preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("priority"),
              (str("high") | str("medium") | str("low"))
            ),
            b(str("prefix-segment"),
                sc(
                    a(str("index"), arg),
                    str("node-segment")
                )
            ).as(:oneline),
            b(str("label-allocation"),
              (str("per-table") | str("per-nexthop") | str("per-table-localize"))
            ),
            b(str("add-path"),
                sc(
                    a(str("send-count"), arg)
                )
            ).as(:oneline),
            b(str("validation-state"),
              (str("valid") | str("invalid") | str("unknown"))
            ),
            b(str("origin"),
              (str("igp") | str("egp") | str("incomplete"))
            ),
            b(str("aigp-originate"),
                sc(
                    a(str("distance"), arg)
                )
            ).as(:oneline),
            b(str("aigp-adjust"),
                sc(
                    c(
                      str("add"),
                      str("subtract"),
                      str("multiply"),
                      str("divide")
                    ),
                    ca(
                      str("distance-to-protocol-nexthop")
                    )
                )
            ).as(:oneline),
            b(str("community"),
                s(
                  c(
                    a(str("="), arg),
                    a(str("set"), arg),
                    a(str("+"), arg),
                    a(str("add"), arg),
                    a(str("-"), arg),
                    a(str("delete"), arg)
                  ),
                        arg
                )
            ).as(:oneline),
            a(str("damping"), arg),
            str("aggregate-bandwidth"),
            a(str("limit-bandwidth"), arg),
            str("no-entropy-label-capability"),
            a(str("as-path-prepend"), quote | arg),
            b(str("as-path-expand"),
                sc(
                    c(
                      b(str("last-as"),
                          sc(
                              a(str("count"), arg)
                          )
                      ).as(:oneline),
                      arg
                    )
                )
            ).as(:oneline),
            b(str("next-hop"),
                sc(
                    c(
                      str("self"),
                      str("peer-address"),
                      str("reject"),
                      str("discard"),
                      a(str("next-table"), arg),
                        ipaddr
                    )
                )
            ).as(:oneline),
            b(str("install-nexthop"),
                sc(
                    c(
                      str("strict"),
                      str("strict-named-lsp")
                    ),
                    c(
                      a(str("lsp"), arg),
                      a(str("lsp-regex"), arg),
                      a(str("static-lsp"), arg),
                      a(str("static-lsp-regex"), arg),
                      str("non-lsp-nexthop"),
                      str("non-labelled-nexthop")
                    ),
                    b(str("except"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("fallback"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    ),
                                    b(str("except"),
                                        c(
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg),
                                              str("non-lsp-nexthop"),
                                              str("non-labelled-nexthop")
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("fallback"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("except"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    )
                                )
                            )
                        )
                    )
                )
            ).as(:oneline),
            str("trace"),
            b(str("external"),
                c(
                    a(str("type"), arg),
                    str("nssa-only")
                )
            ),
            b(str("load-balance"),
                sc(
                    c(
                      str("per-packet"),
                      str("random"),
                      str("per-prefix"),
                      str("consistent-hash"),
                      str("source-ip-only"),
                      str("destination-ip-only")
                    )
                )
            ).as(:oneline),
            str("no-route-localize"),
            str("install-to-fib"),
            str("no-install-to-fib"),
            str("analyze"),
            a(str("class"), arg),
            a(str("destination-class"), arg),
            a(str("source-class"), arg),
            a(str("forwarding-class"), arg),
            b(str("map-to-interface"),
                sc(
                    c(
                      str("self"),
                        interface_name
                    )
                )
            ).as(:oneline),
            b(str("ssm-source"),
              ipaddr
            ),
            b(str("p2mp-lsp-root"),
                c(
                    b(str("address"),
                      ipv4addr
                    )
                )
            ),
            a(str("cos-next-hop-map"), arg),
            a(str("dynamic-tunnel-attributes"), arg),
            str("selected-mldp-egress"),
            str("mhop-bfd-port"),
            str("no-backup"),
            b(str("default-action"),
              (str("accept") | str("reject"))
            ),
            b(str("next"),
              (str("policy") | str("term"))
            ),
            c(
              str("accept"),
              str("reject")
            ),
            b(str("bgp-output-queue-priority"),
                sc(
                    c(
                      a(str("priority"), arg),
                      str("expedited")
                    )
                )
            ).as(:oneline),
            str("multipath-resolve"),
            a(str("sr-te-template"), arg),
            str("label-allocation-fallback-reject"),
            a(str("resolution-map"), arg)
          )
        )
    end

    rule(:juniper_port_mirror_options) do
        c(
            b(str("traceoptions"),
              sampling_traceoptions_type
            ),
            str("disable"),
            str("disable-all-instances"),
            str("mirror-once"),
            str("no-preserve-ingress-tag"),
            b(str("input"),
              pm_family_input_type
            ),
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            b(str("input"),
                              pm_family_input_type
                            ),
                            b(str("output"),
                              inet_pm_family_output_type
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                            b(str("input"),
                              pm_family_input_type
                            ),
                            b(str("output"),
                              inet6_pm_family_output_type
                            )
                        )
                    ),
                    b(str("mpls"),
                        c(
                            b(str("input"),
                              pm_family_input_type
                            ),
                            b(str("output"),
                              mpls_pm_family_output_type
                            )
                        )
                    ),
                    b(str("any"),
                        c(
                            b(str("output"),
                              any_pm_family_output_type
                            )
                        )
                    ),
                    b(str("vpls"),
                        c(
                            b(str("input"),
                              pm_family_input_type
                            ),
                            b(str("output"),
                              layer2_pm_family_output_type
                            )
                        )
                    ),
                    b(str("ethernet-switching"),
                        c(
                            b(str("output"),
                              layer2_pm_family_output_type
                            )
                        )
                    ),
                    b(str("ccc"),
                        c(
                            b(str("input"),
                              pm_family_input_type
                            ),
                            b(str("output"),
                              layer2_pm_family_output_type
                            )
                        )
                    )
                )
            ),
            b(a(str("instance"), arg),
                c(
                    str("disable"),
                    c(
                      b(str("input"),
                        pm_family_input_type
                      ),
                      a(str("input-parameters-instance"), arg)
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("input"),
                                      pm_family_input_type
                                    ),
                                    b(str("output"),
                                      inet_pm_family_output_type
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("input"),
                                      pm_family_input_type
                                    ),
                                    b(str("output"),
                                      inet6_pm_family_output_type
                                    )
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    b(str("input"),
                                      pm_family_input_type
                                    ),
                                    b(str("output"),
                                      mpls_pm_family_output_type
                                    )
                                )
                            ),
                            b(str("any"),
                                c(
                                    b(str("output"),
                                      any_pm_family_output_type
                                    )
                                )
                            ),
                            b(str("vpls"),
                                c(
                                    b(str("input"),
                                      pm_family_input_type
                                    ),
                                    b(str("output"),
                                      layer2_pm_family_output_type
                                    )
                                )
                            ),
                            b(str("ethernet-switching"),
                                c(
                                    b(str("output"),
                                      layer2_pm_family_output_type
                                    )
                                )
                            ),
                            b(str("ccc"),
                                c(
                                    b(str("input"),
                                      pm_family_input_type
                                    ),
                                    b(str("output"),
                                      layer2_pm_family_output_type
                                    )
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:any_pm_family_output_type) do
        c(
            c(
              b(str("interface"),
                any_pm_intf_type
              ),
              a(str("next-hop-group"), arg)
            ),
            str("no-filter-check"),
            b(str("hosted-service"),
                c(
                    a(str("server-profile"), arg)
                )
            )
        )
    end

    rule(:any_pm_intf_type) do
      b(arg.as(:arg),
        c(
            b(str("next-hop"),
              inet_next_hop_type
            )
        )
      )
    end

    rule(:inet6_pm_family_output_type) do
        c(
            c(
              b(str("interface"),
                inet6_pm_intf_type
              ),
              a(str("next-hop-group"), arg)
            ),
            str("no-filter-check"),
            a(str("server-profile"), arg)
        )
    end

    rule(:inet6_pm_intf_type) do
      b(arg.as(:arg),
        c(
            b(str("next-hop"),
              inet6_next_hop_type
            )
        )
      )
    end

    rule(:inet6_next_hop_type) do
      arg.as(:arg)
    end

    rule(:inet_next_hop_type) do
      arg.as(:arg)
    end

    rule(:inet_pm_family_output_type) do
        c(
            c(
              b(str("interface"),
                inet_pm_intf_type
              ),
              a(str("next-hop-group"), arg)
            ),
            str("no-filter-check"),
            b(str("ip-address"),
              ipv4addr
            ),
            b(str("routing-instance"),
              inet_pm_output_routing_instance_type
            ),
            a(str("server-profile"), arg)
        )
    end

    rule(:inet_pm_intf_type) do
      b(arg.as(:arg),
        c(
            b(str("next-hop"),
              inet_next_hop_type
            )
        )
      )
    end

    rule(:inet_pm_output_routing_instance_type) do
      b(arg.as(:arg),
        c(
            b(str("ip-address"),
              ipv4addr
            )
        )
      )
    end

    rule(:juniper_protected_system_domain) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("fpcs"), arg),
            b(a(str("lcc"), arg),
                c(
                    a(str("fpcs"), arg)
                )
            ),
            a(str("control-system-id"), arg),
            a(str("control-slot-numbers"), arg),
            a(str("control-plane-bandwidth-percent"), arg)
        )
      )
    end

    rule(:juniper_protected_system_domain_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("configuration") | str("rtsock") | str("ipc") | str("init") | str("psd") | str("all"))).as(:oneline)
        )
    end

    rule(:juniper_protocols) do
        c(
            b(str("router-advertisement"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"))).as(:oneline)
                        )
                    ),
                    a(str("interface"), arg | arg,
                        c(
                            b(str("preference"),
                              (str("medium") | str("high") | str("low"))
                            ),
                            a(str("max-advertisement-interval"), arg),
                            a(str("min-advertisement-interval"), arg),
                            str("managed-configuration"),
                            str("no-managed-configuration"),
                            str("other-stateful-configuration"),
                            str("no-other-stateful-configuration"),
                            str("link-mtu"),
                            str("no-link-mtu"),
                            str("solicit-router-advertisement-unicast"),
                            a(str("reachable-time"), arg),
                            a(str("retransmit-timer"), arg),
                            str("virtual-router-only"),
                            a(str("current-hop-limit"), arg),
                            a(str("default-lifetime"), arg),
                            a(str("dns-server-address"), arg | arg,
                                c(
                                    a(str("lifetime"), arg)
                                )
                            ),
                            b(a(str("prefix"), arg),
                                c(
                                    a(str("valid-lifetime"), arg),
                                    str("on-link"),
                                    str("no-on-link"),
                                    a(str("preferred-lifetime"), arg),
                                    str("autonomous"),
                                    str("no-autonomous")
                                )
                            )
                        )
                    ),
                    b(str("ra-secure"),
                        c(
                            a(str("accept-current-hop-limit-min"), arg),
                            a(str("accept-current-hop-limit-max"), arg),
                            a(str("accept-reachable-time-min"), arg),
                            a(str("accept-reachable-time-max"), arg),
                            a(str("accept-retransmit-time-min"), arg),
                            a(str("accept-retransmit-time-max"), arg)
                        )
                    )
                )
            ),
            b(str("neighbor-discovery"),
                c(
                    str("onlink-subnet-only"),
                    str("no-dad-on-state-change"),
                    b(str("ndp-proxy"),
                        c(
                            str("no-proxy-on-resolve")
                        )
                    ),
                    b(str("dad-proxy"),
                        c(
                            str("no-proxy-on-resolve")
                        )
                    ),
                    b(str("secure"),
                        c(
                            b(str("security-level"),
                                c(
                                    c(
                                      str("default"),
                                      str("secure-messages-only")
                                    )
                                )
                            ),
                            b(str("cryptographic-address"),
                                c(
                                    a(str("key-length"), arg),
                                    a(str("key-pair"), arg)
                                )
                            ),
                            b(str("timestamp"),
                                c(
                                    a(str("new-peer-window"), arg),
                                    a(str("known-peer-window"), arg),
                                    b(str("clock-drift"),
                                      unsigned_float
                                    )
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("cryptographic-address") | str("configuration") | str("protocol") | str("rsa") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("iccp"),
                c(
                    b(str("local-ip-addr"),
                      ipv4addr
                    ),
                    a(str("session-establishment-hold-time"), arg),
                    a(str("authentication-key"), arg),
                    b(str("peer"),
                      peer_group
                    ),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("error") | str("event") | str("packet") | str("pipe") | str("pipe-detail") | str("all"))).as(:oneline)
                        )
                    )
                )
            ),
            b(str("ilmi"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("database") | str("routing-socket") | str("state") | str("debug") | str("event") | str("packet") | str("all"))).as(:oneline)
                        )
                    )
                )
            ),
            b(str("lacp"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("configuration") | str("routing-socket") | str("process") | str("startup") | str("protocol") | str("packet") | str("ppm") | str("bfd") | str("mc-ae") | str("all"))).as(:oneline)
                        )
                    ),
                    b(str("ppm"),
                      (str("centralized") | str("inline"))
                    ),
                    str("fast-hello-issu")
                )
            ),
            b(str("oam"),
                c(
                    b(str("ethernet"),
                        c(
                            b(str("link-fault-management"),
                                c(
                                    str("hardware-assisted-keepalives"),
                                    b(str("traceoptions"),
                                        c(
                                            str("no-remote-trace"),
                                            b(str("file"),
                                                sc(
                                                      arg,
                                                    a(str("size"), arg),
                                                    a(str("files"), arg),
                                                    str("world-readable"),
                                                    str("no-world-readable"),
                                                    b(str("match"),
                                                      regular_expression
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("flag"), enum(str("configuration") | str("routing-socket") | str("protocol") | str("action-profile") | str("all"))).as(:oneline)
                                        )
                                    ),
                                    b(a(str("action-profile"), arg),
                                        c(
                                            b(str("event"),
                                                c(
                                                    str("link-adjacency-loss"),
                                                    str("protocol-down"),
                                                    b(str("link-event-rate"),
                                                        c(
                                                            a(str("symbol-period"), arg),
                                                            a(str("frame-error"), arg),
                                                            a(str("frame-period"), arg),
                                                            a(str("frame-period-summary"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("action"),
                                                c(
                                                    str("syslog"),
                                                    str("link-down"),
                                                    str("send-critical-event")
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("interface"), arg),
                                        c(
                                            a(str("apply-action-profile"), arg),
                                            a(str("pdu-interval"), arg),
                                            str("loopback-tracking"),
                                            str("detect-loc"),
                                            b(str("link-discovery"),
                                              (str("active") | str("passive"))
                                            ),
                                            a(str("pdu-threshold"), arg),
                                            str("remote-loopback"),
                                            b(str("negotiation-options"),
                                                c(
                                                    str("no-allow-link-events"),
                                                    str("allow-remote-loopback")
                                                )
                                            ),
                                            b(str("event-thresholds"),
                                                c(
                                                    a(str("symbol-period"), arg),
                                                    a(str("frame-error"), arg),
                                                    a(str("frame-period"), arg),
                                                    a(str("frame-period-summary"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("connectivity-fault-management"),
                                c(
                                    b(str("performance-monitoring"),
                                        c(
                                            str("hardware-assisted-timestamping"),
                                            str("delegate-server-processing"),
                                            b(str("hardware-assisted-keepalives"),
                                              (str("enable") | str("disable"))
                                            ),
                                            str("hardware-assisted-pm"),
                                            str("enhanced-sla-iterator"),
                                            b(str("measurement-interval"),
                                              (str("2") | str("5") | str("15") | str("30") | str("60"))
                                            ),
                                            str("legacy-pm-display"),
                                            b(a(str("sla-iterator-profiles"), arg),
                                                c(
                                                    str("disable"),
                                                    b(str("measurement-type"),
                                                      (str("two-way-delay") | str("loss") | str("slm") | str("statistical-frame-loss"))
                                                    ),
                                                    a(str("flap-trap-monitor"), arg),
                                                    a(str("cycle-time"), arg),
                                                    a(str("iteration-period"), arg),
                                                    b(str("calculation-weight"),
                                                        c(
                                                            a(str("delay"), arg),
                                                            a(str("delay-variation"), arg)
                                                        )
                                                    ),
                                                    b(str("avg-flr-forward-threshold"),
                                                        ca(
                                                            a(str("flap-trap-monitor"), arg)
                                                        )
                                                    ),
                                                    b(str("avg-flr-backward-threshold"),
                                                        ca(
                                                            a(str("flap-trap-monitor"), arg)
                                                        )
                                                    ),
                                                    b(str("avg-fd-twoway-threshold"),
                                                        ca(
                                                            a(str("flap-trap-monitor"), arg)
                                                        )
                                                    ),
                                                    b(str("avg-fdv-twoway-threshold"),
                                                        ca(
                                                            a(str("flap-trap-monitor"), arg)
                                                        )
                                                    ),
                                                    b(str("measurement-interval"),
                                                      (str("2") | str("5") | str("15") | str("30") | str("60"))
                                                    ),
                                                    b(str("frame-delay"),
                                                        c(
                                                            a(str("num-bins"), arg),
                                                            b(str("two-way"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            ),
                                                            b(str("forward"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            ),
                                                            b(str("backward"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("frame-delay-range"),
                                                        c(
                                                            a(str("num-bins"), arg),
                                                            b(str("two-way"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            ),
                                                            b(str("forward"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            ),
                                                            b(str("backward"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("ifdv"),
                                                        c(
                                                            a(str("num-bins"), arg),
                                                            b(str("two-way"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            ),
                                                            b(str("forward"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            ),
                                                            b(str("backward"),
                                                                c(
                                                                    a(str("lower-threshold-bin"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("availability"),
                                                        c(
                                                            a(str("num-consecutive-pdus"), arg),
                                                            a(str("flr-threshold"), arg),
                                                            a(str("num-consecutive-intervals"), arg),
                                                            a(str("num-consecutive-highflr"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(a(str("interface"), arg),
                                                sc(
                                                    str("enable-multiclass-loss-measurement"),
                                                    str("code-point-based-lm-accounting"),
                                                    str("priority-based-lm-accounting")
                                                )
                                            ).as(:oneline),
                                            str("enable-multiclass-loss-measurement"),
                                            str("code-point-based-lm-accounting"),
                                            str("priority-based-lm-accounting"),
                                            str("colorless-loss-measurement")
                                        )
                                    ),
                                    b(str("connection-protection"),
                                        c(
                                            str("mark-connection-protection-tlv"),
                                            str("uhp-label-lookup")
                                        )
                                    ),
                                    str("no-aggregate-delegate-processing"),
                                    str("enhanced-cfm-mode"),
                                    b(str("expected-defect"),
                                        c(
                                            str("rx-enable"),
                                            a(str("rx-max-duration"), arg),
                                            str("tx-enable"),
                                            a(str("tx-duration"), arg)
                                        )
                                    ),
                                    b(str("traceoptions"),
                                      cfm_traceoptions
                                    ),
                                    b(a(str("action-profile"), arg),
                                        c(
                                            b(str("event"),
                                                c(
                                                    b(str("interface-status-tlv"),
                                                      (str("down") | str("lower-layer-down"))
                                                    ),
                                                    b(str("port-status-tlv"),
                                                      (str("blocked"))
                                                    ),
                                                    str("adjacency-loss"),
                                                    str("rdi"),
                                                    b(str("connection-protection-tlv"),
                                                      (str("using-working-path") | str("using-protection-path"))
                                                    ),
                                                    b(str("server-mep-defects"),
                                                      (str("link-loss-defect") | str("l2circuit-defect") | str("l2vpn-defect"))
                                                    ),
                                                    b(str("ais-trigger-condition"),
                                                      (str("all-defects") | str("adjacency-loss") | str("cross-connect-ccm") | str("erroneous-ccm") | str("receive-ais"))
                                                    )
                                                )
                                            ),
                                            b(str("action"),
                                                c(
                                                    str("interface-down"),
                                                    str("revertive-interface-down"),
                                                    str("non-revertive-interface-down"),
                                                    str("propagate-remote-mac-flush"),
                                                    str("interface-group-down"),
                                                    b(str("log-and-generate-ais"),
                                                        c(
                                                            a(str("level"), arg),
                                                            b(str("interval"),
                                                              (str("1s") | str("1m"))
                                                            ),
                                                            a(str("priority"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("clear-action"),
                                                c(
                                                    b(str("interface-down"),
                                                        sc(
                                                            str("peer-interface")
                                                        )
                                                    ).as(:oneline),
                                                    str("propagate-remote-mac-flush")
                                                )
                                            ),
                                            b(str("default-actions"),
                                                c(
                                                    str("interface-down")
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("server-mep"), arg),
                                        c(
                                            b(str("protocol"),
                                                c(
                                                    c(
                                                      b(str("l2circuit"),
                                                          sc(
                                                              b(str("interface"),
                                                                  sc(
                                                                        interface_name
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("l2vpn"),
                                                          sc(
                                                              b(str("interface"),
                                                                  sc(
                                                                        interface_name
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("ethernet"),
                                                          sc(
                                                              b(str("interface"),
                                                                  sc(
                                                                        interface_device
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ).as(:oneline)
                                                    )
                                                )
                                            ),
                                            b(str("action-profile"),
                                                c(
                                                    arg
                                                )
                                            )
                                        )
                                    ),
                                    b(str("policer"),
                                        c(
                                            a(str("continuity-check"), arg),
                                            a(str("other"), arg),
                                            a(str("all"), arg)
                                        )
                                    ),
                                    b(str("linktrace"),
                                        c(
                                            a(str("path-database-size"), arg),
                                            b(str("age"),
                                              (str("10s") | str("30s") | str("1m") | str("10m") | str("30m"))
                                            )
                                        )
                                    ),
                                    a(str("maintenance-domain"), str("default-0") | str("default-1") | str("default-2") | str("default-3") | str("default-4") | str("default-5") | str("default-6") | str("default-7") | arg,
                                        c(
                                            b(a(str("bridge-domain"), arg),
                                                sc(
                                                    a(str("vlan-id"), arg)
                                                )
                                            ).as(:oneline),
                                            a(str("vlan"), arg).as(:oneline),
                                            b(a(str("virtual-switch"), arg),
                                                c(
                                                    b(a(str("bridge-domain"), arg),
                                                        sc(
                                                            a(str("vlan-id"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("instance"), arg).as(:oneline),
                                            a(str("interface"), arg).as(:oneline),
                                            a(str("level"), arg),
                                            b(str("name-format"),
                                              (str("none") | str("dns") | str("mac+2oct") | str("character-string"))
                                            ),
                                            b(str("mip-half-function"),
                                              (str("none") | str("default") | str("explicit"))
                                            ),
                                            b(a(str("maintenance-association"), arg),
                                                c(
                                                    str("debug-session"),
                                                    b(str("short-name-format"),
                                                      (str("2octet") | str("rfc-2685-vpn-id") | str("vlan") | str("character-string") | str("icc"))
                                                    ),
                                                    b(str("protect-maintenance-association"),
                                                        sc(
                                                              arg,
                                                            a(str("aps-profile"), arg),
                                                            str("detect-path-type")
                                                        )
                                                    ).as(:oneline),
                                                    b(str("primary-vid"),
                                                      (str("none") | arg)
                                                    ),
                                                    b(str("continuity-check"),
                                                        c(
                                                            b(str("interval"),
                                                              (str("10ms") | str("100ms") | str("1s") | str("10s") | str("1m") | str("10m") | str("3.3ms"))
                                                            ),
                                                            a(str("loss-threshold"), arg),
                                                            a(str("hold-interval"), arg),
                                                            str("port-status-tlv"),
                                                            str("interface-status-tlv"),
                                                            str("connection-protection-tlv"),
                                                            str("convey-loss-threshold"),
                                                            str("interface-status-send-rdi"),
                                                            b(str("sendid-tlv"),
                                                                c(
                                                                    str("send-chassis-tlv")
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("mip-half-function"),
                                                      (str("none") | str("default") | str("explicit") | str("defer"))
                                                    ),
                                                    b(a(str("mep"), arg),
                                                        c(
                                                            b(str("interface"),
                                                                sc(
                                                                      interface_unit,
                                                                    a(str("vlan"), arg),
                                                                    c(
                                                                      str("working"),
                                                                      str("protect")
                                                                    )
                                                                )
                                                            ).as(:oneline),
                                                            b(str("direction"),
                                                              (str("up") | str("down"))
                                                            ),
                                                            a(str("priority"), arg),
                                                            str("auto-discovery"),
                                                            a(str("action-profile"), arg),
                                                            b(a(str("remote-mep"), arg),
                                                                c(
                                                                    a(str("action-profile"), arg),
                                                                    b(str("interface-group"),
                                                                        c(
                                                                              interface_device,
                                                                            a(str("unit-list"), arg)
                                                                        )
                                                                    ),
                                                                    b(a(str("sla-iterator-profile"), arg),
                                                                        c(
                                                                            a(str("iteration-count"), arg),
                                                                            a(str("priority"), arg),
                                                                            a(str("data-tlv-size"), arg)
                                                                        )
                                                                    ),
                                                                    str("detect-loc")
                                                                )
                                                            ),
                                                            b(str("lowest-priority-defect"),
                                                              (str("all-defects") | str("mac-rem-err-xcon") | str("rem-err-xcon") | str("err-xcon") | str("xcon") | str("no-defect"))
                                                            )
                                                        )
                                                    ),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("continuity-check"), arg),
                                                            a(str("other"), arg),
                                                            a(str("all"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("sendid-tlv"),
                                        c(
                                            str("send-chassis-tlv")
                                        )
                                    )
                                )
                            ),
                            b(a(str("evcs"), arg),
                                c(
                                    b(str("evc-protocol"),
                                        sc(
                                            c(
                                              b(str("cfm"),
                                                  sc(
                                                      a(str("maintenance-domain"), arg),
                                                      a(str("maintenance-association"), arg),
                                                      a(str("mep"), arg),
                                                      b(str("faults"),
                                                          c(
                                                              str("rdi")
                                                          )
                                                      )
                                                  )
                                              ).as(:oneline),
                                              b(str("vpls"),
                                                  sc(
                                                      a(str("routing-instance"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("l2circuit"),
                                                  c(
                                                      b(str("interface"),
                                                          sc(
                                                                interface_name
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              ),
                                              b(str("l2vpn"),
                                                  c(
                                                      b(str("interface"),
                                                          sc(
                                                                interface_name
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              )
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("remote-uni-count"), arg),
                                    a(str("async-status-msg-transmit-interval"), arg),
                                    str("multipoint-to-multipoint")
                                )
                            ),
                            b(str("lmi"),
                                c(
                                    b(str("traceoptions"),
                                        c(
                                            str("no-remote-trace"),
                                            b(str("file"),
                                                sc(
                                                      arg,
                                                    a(str("size"), arg),
                                                    a(str("files"), arg),
                                                    str("world-readable"),
                                                    str("no-world-readable"),
                                                    b(str("match"),
                                                      regular_expression
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("flag"), enum(str("configuration") | str("routing-socket") | str("protocol") | str("init") | str("error") | str("packet") | str("all"))).as(:oneline)
                                        )
                                    ),
                                    a(str("status-counter"), arg),
                                    a(str("polling-verification-timer"), arg),
                                    b(a(str("interface"), arg),
                                        c(
                                            a(str("uni-id"), arg),
                                            a(str("status-counter"), arg),
                                            a(str("polling-verification-timer"), arg),
                                            b(str("evc-map-type"),
                                              (str("all-to-one-bundling") | str("service-multiplexing") | str("bundling"))
                                            ),
                                            b(a(str("evc"), arg),
                                                c(
                                                    str("default-evc"),
                                                    a(str("vlan-list"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("fnp"),
                                c(
                                    b(str("traceoptions"),
                                        c(
                                            b(str("file"),
                                                sc(
                                                      arg,
                                                    str("replace"),
                                                    a(str("size"), arg),
                                                    a(str("files"), arg),
                                                    str("no-stamp"),
                                                    str("world-readable"),
                                                    str("no-world-readable")
                                                )
                                            ).as(:oneline),
                                            a(str("flag"), enum(str("events") | str("pdu") | str("timers") | str("error") | str("all"))).as(:oneline)
                                        )
                                    ),
                                    b(str("interval"),
                                      (str("100ms") | str("1s") | str("10s") | str("1m") | str("10m"))
                                    ),
                                    a(str("loss-threshold"), arg),
                                    b(a(str("interface"), arg),
                                        c(
                                            a(str("domain-id"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("gre-tunnel"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("configuration") | str("routing-socket") | str("protocol") | str("snmp") | str("all"))).as(:oneline)
                                )
                            ),
                            b(a(str("interface"), arg),
                                c(
                                    a(str("keepalive-time"), arg),
                                    a(str("hold-time"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("ancp"),
              juniper_protocols_ancp
            ),
            b(str("bfd"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("adjacency") | str("event") | str("error") | str("rtsock") | str("packet") | str("ppm-packet") | str("pipe") | str("pipe-detail") | str("state") | str("timer") | str("nsr-synchronization") | str("nsr-packet") | str("issu") | str("slow-start") | str("session") | str("all"))).as(:oneline)
                        )
                    ),
                    str("no-issu-timer-negotiation"),
                    b(str("sbfd"),
                        c(
                            a(str("pool"), arg),
                            b(a(str("local-discriminator"), arg),
                                c(
                                    a(str("minimum-receive-interval"), arg),
                                    b(str("local-ip-address"),
                                      ipv4addr
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("ptp"),
                c(
                    b(str("clock-mode"),
                      (str("ordinary") | str("boundary"))
                    ),
                    b(str("profile-type"),
                      (str("g.8275.1") | str("g.8275.1.enh") | str("g.8275.2.enh") | str("enterprise-profile") | str("smpte") | str("aes67") | str("aes67-smpte"))
                    ),
                    str("e2e-transparent"),
                    b(str("timescale"),
                      (str("arbitrary"))
                    ),
                    a(str("priority1"), arg),
                    a(str("priority2"), arg),
                    a(str("local-priority"), arg),
                    a(str("domain"), arg),
                    str("path-trace"),
                    str("unicast-negotiation"),
                    str("phy-timestamping"),
                    a(str("ipv4-dscp"), arg),
                    a(str("ipv6-dscp"), arg),
                    b(str("performance-monitor"),
                        c(
                            b(str("threshold"),
                                c(
                                    a(str("min-outbound-delay"), arg),
                                    a(str("max-outbound-delay"), arg),
                                    a(str("min-inbound-delay"), arg),
                                    a(str("max-inbound-delay"), arg),
                                    a(str("max-inbound-jitter-neg"), arg),
                                    a(str("max-inbound-jitter-pos"), arg),
                                    a(str("max-outbound-jitter-neg"), arg),
                                    a(str("max-outbound-jitter-pos"), arg)
                                )
                            )
                        )
                    ),
                    a(str("utc-leap-seconds"), arg),
                    b(str("slave"),
                        c(
                            str("frequency-only"),
                            a(str("delay-request"), arg),
                            a(str("announce-timeout"), arg),
                            a(str("announce-interval"), arg),
                            a(str("sync-interval"), arg),
                            a(str("grant-duration"), arg),
                            str("convert-clock-class-to-quality-level"),
                            b(str("clock-class-to-quality-level-mapping"),
                                c(
                                    a(str("quality-level"), enum(str("prc") | str("ssu-a") | str("ssu-b") | str("sec") | str("prs") | str("st2") | str("tnc") | str("st3e") | str("st3") | str("smc") | str("st4") | str("stu")),
                                        c(
                                            a(str("clock-class"), arg)
                                        )
                                    )
                                )
                            ),
                            b(a(str("interface"), arg),
                                c(
                                    b(str("unicast-mode"),
                                        c(
                                            b(str("transport"),
                                              (str("ipv4") | str("ipv6"))
                                            ),
                                            a(str("local-priority"), arg),
                                            b(str("clock-source"),
                                                s(
                                                        arg,
                                                  a(str("local-ip-address"), arg),
                                                  c(
                                                    a(str("asymmetry"), arg),
                                                    a(str("primary-asymmetry"), arg),
                                                    a(str("secondary-asymmetry"), arg)
                                                  )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("multicast-mode"),
                                        c(
                                            b(str("transport"),
                                                c(
                                                    c(
                                                      b(str("ieee-802.3"),
                                                          sc(
                                                              str("link-local")
                                                          )
                                                      ).as(:oneline),
                                                      str("ipv4").as(:oneline)
                                                    )
                                                )
                                            ),
                                            a(str("local-priority"), arg),
                                            a(str("asymmetry"), arg),
                                            a(str("primary-asymmetry"), arg),
                                            a(str("secondary-asymmetry"), arg),
                                            b(str("local-ip-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    a(str("primary"), arg),
                                    a(str("secondary"), arg)
                                )
                            ),
                            b(str("hybrid"),
                                c(
                                    b(str("periodic-alignment"),
                                      (str("enable") | str("disable"))
                                    ),
                                    a(str("re-alignment-threshold"), arg),
                                    b(str("synchronous-ethernet-mapping"),
                                        c(
                                            b(a(str("clock-source"), arg),
                                                c(
                                                    a(str("interface"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("master"),
                        c(
                            a(str("announce-interval"), arg),
                            a(str("sync-interval"), arg),
                            a(str("min-announce-interval"), arg),
                            a(str("max-announce-interval"), arg),
                            a(str("min-sync-interval"), arg),
                            a(str("max-sync-interval"), arg),
                            a(str("min-delay-response-interval"), arg),
                            a(str("max-delay-response-interval"), arg),
                            a(str("delay-req-timeout"), arg),
                            b(str("clock-step"),
                              (str("one-step") | str("two-step"))
                            ),
                            b(a(str("interface"), arg),
                                c(
                                    b(str("unicast-mode"),
                                        c(
                                            b(str("transport"),
                                              (str("ipv4") | str("ipv6"))
                                            ),
                                            b(str("clock-client"),
                                                s(
                                                        arg,
                                                  a(str("local-ip-address"), arg),
                                                  c(
                                                    str("manual")
                                                  )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("multicast-mode"),
                                        c(
                                            b(str("transport"),
                                                c(
                                                    c(
                                                      b(str("ieee-802.3"),
                                                          sc(
                                                              str("link-local")
                                                          )
                                                      ).as(:oneline),
                                                      str("ipv4").as(:oneline)
                                                    )
                                                )
                                            ),
                                            a(str("local-priority"), arg),
                                            b(str("local-ip-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    a(str("primary"), arg),
                                    a(str("secondary"), arg)
                                )
                            )
                        )
                    ),
                    b(str("stateful"),
                        c(
                            b(a(str("interface"), arg),
                                c(
                                    b(str("multicast-mode"),
                                        c(
                                            b(str("transport"),
                                                c(
                                                    c(
                                                      b(str("ieee-802.3"),
                                                          sc(
                                                              str("link-local")
                                                          )
                                                      ).as(:oneline)
                                                    )
                                                )
                                            ),
                                            a(str("local-priority"), arg),
                                            a(str("asymmetry"), arg),
                                            a(str("primary-asymmetry"), arg),
                                            a(str("secondary-asymmetry"), arg)
                                        )
                                    ),
                                    a(str("primary"), arg),
                                    a(str("secondary"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("clock-synchronization"),
                c(
                    b(str("traceoptions"),
                      clksync_traceoptions
                    )
                )
            ),
            b(str("dot1x"),
              juniper_protocols_dot1x
            ),
            b(str("ppp-service"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            b(str("level"),
                              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                            ),
                            a(str("flag"), enum(str("accounting-statistics") | str("authentication") | str("chap") | str("events") | str("gres") | str("init") | str("interface-db") | str("lcp") | str("memory") | str("ncp") | str("packet-error") | str("pap") | str("parse") | str("profile") | str("receive-packets") | str("routing-process") | str("rtp") | str("rtsock") | str("session-db") | str("smi-services-sentry") | str("states") | str("transmit-packets") | str("tunnel") | str("all"))).as(:oneline),
                            b(str("filter"),
                                c(
                                    a(str("aci"), arg),
                                    a(str("ari"), arg),
                                    a(str("service-name"), arg),
                                    b(str("underlying-interface"),
                                      (arg | arg)
                                    ),
                                    b(str("user"),
                                        c(
                                              arg
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("on-demand-ip-address"),
                    str("reject-unauthorized-ipv6cp"),
                    b(str("required-address"),
                        c(
                            str("ip")
                        )
                    ),
                    str("pppoe-lcp-options-strict"),
                    b(str("source-interface-set-at-login"),
                      (str("svlan"))
                    )
                )
            ),
            b(str("msdp"),
              juniper_protocols_msdp
            ),
            b(str("isis"),
              juniper_protocols_isis
            ),
            b(str("esis"),
              juniper_protocols_esis
            ),
            b(str("ospf"),
              juniper_protocols_ospf
            ),
            b(str("overlay"),
              juniper_protocols_overlayd
            ),
            b(str("l2iw"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("error") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("igmp"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("mtrace") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("query-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    a(str("maximum-transmit-rate"), arg),
                    str("accounting"),
                    a(str("interface"), arg | arg,
                        c(
                              (str("disable")),
                            a(str("version"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            b(str("group-increment"),
                                              ipv4addr
                                            ),
                                            a(str("group-count"), arg),
                                            str("exclude"),
                                            b(a(str("source"), arg),
                                                c(
                                                    b(str("source-increment"),
                                                      ipv4addr
                                                    ),
                                                    a(str("source-count"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("ssm-map"), arg),
                            b(str("ssm-map-policy"),
                              policy_algebra
                            ),
                            str("immediate-leave"),
                            str("promiscuous-mode"),
                            str("accounting"),
                            str("no-accounting"),
                            b(str("group-policy"),
                              policy_algebra
                            ),
                            a(str("group-limit"), arg),
                            a(str("group-threshold"), arg),
                            a(str("log-interval"), arg),
                            b(str("passive"),
                                sc(
                                    str("allow-receive"),
                                    str("send-general-query"),
                                    str("send-group-query")
                                )
                            ).as(:oneline),
                            b(str("oif-map"),
                              policy_algebra
                            ),
                            str("distributed")
                        )
                    ),
                    b(str("amt"),
                        c(
                            b(str("relay"),
                                c(
                                    b(str("defaults"),
                                        c(
                                            a(str("version"), arg),
                                            a(str("ssm-map"), arg),
                                            b(str("ssm-map-policy"),
                                              policy_algebra
                                            ),
                                            str("accounting"),
                                            str("no-accounting"),
                                            b(str("group-policy"),
                                              policy_algebra
                                            ),
                                            a(str("group-limit"), arg),
                                            a(str("group-threshold"), arg),
                                            a(str("log-interval"), arg),
                                            a(str("robust-count"), arg),
                                            a(str("query-interval"), arg),
                                            a(str("query-response-interval"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("mld"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("mtrace") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("query-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    a(str("maximum-transmit-rate"), arg),
                    str("accounting"),
                    a(str("interface"), arg | arg,
                        c(
                              (str("disable")),
                            a(str("version"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            b(str("group-increment"),
                                              ipv6addr
                                            ),
                                            a(str("group-count"), arg),
                                            str("exclude"),
                                            b(a(str("source"), arg),
                                                c(
                                                    b(str("source-increment"),
                                                      ipv6addr
                                                    ),
                                                    a(str("source-count"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("ssm-map"), arg),
                            b(str("ssm-map-policy"),
                              policy_algebra
                            ),
                            str("immediate-leave"),
                            b(str("group-policy"),
                              policy_algebra
                            ),
                            a(str("group-limit"), arg),
                            a(str("group-threshold"), arg),
                            a(str("log-interval"), arg),
                            str("accounting"),
                            str("no-accounting"),
                            b(str("passive"),
                                sc(
                                    str("allow-receive"),
                                    str("send-general-query"),
                                    str("send-group-query")
                                )
                            ).as(:oneline),
                            b(str("oif-map"),
                              policy_algebra
                            ),
                            str("distributed")
                        )
                    )
                )
            ),
            b(str("amt"),
              juniper_protocols_amt
            ),
            b(str("sap"),
                c(
                      (str("disable")),
                    b(a(str("listen"), arg),
                        sc(
                            a(str("port"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("rsvp"),
              juniper_protocols_rsvp
            ),
            b(str("dvmrp"),
                c(
                      (str("disable")),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("route") | str("poison") | str("packets") | str("probe") | str("report") | str("neighbor") | str("prune") | str("graft") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("rib-group"),
                      rib_group_inet_type
                    ),
                    b(str("import"),
                      policy_algebra
                    ),
                    b(str("export"),
                      policy_algebra
                    ),
                    b(a(str("interface"), arg),
                        c(
                              (str("disable")),
                            b(str("mode"),
                              (str("forwarding") | str("unicast-routing"))
                            ),
                            a(str("metric"), arg),
                            a(str("hold-time"), arg)
                        )
                    )
                )
            ),
            b(str("pim"),
              juniper_protocols_pim
            ),
            b(str("rip"),
              juniper_protocols_rip
            ),
            b(str("ripng"),
              juniper_protocols_ripng
            ),
            b(str("connections"),
                c(
                    b(a(str("interface-switch"), arg),
                        c(
                            a(str("interface"), arg)
                        )
                    ),
                    b(a(str("remote-interface-switch"), arg),
                        c(
                            b(str("interface"),
                              interface_name
                            ),
                            a(str("transmit-lsp"), arg),
                            a(str("receive-lsp"), arg)
                        )
                    ),
                    b(a(str("lsp-switch"), arg),
                        c(
                            a(str("transmit-lsp"), arg),
                            a(str("receive-lsp"), arg)
                        )
                    ),
                    b(a(str("p2mp-transmit-switch"), arg),
                        c(
                            b(str("input-interface"),
                              interface_name
                            ),
                            a(str("transmit-p2mp-lsp"), arg),
                            b(str("output-interface"),
                              interface_name
                            )
                        )
                    ),
                    b(a(str("p2mp-receive-switch"), arg),
                        c(
                            a(str("receive-p2mp-lsp"), arg),
                            b(str("output-interface"),
                              interface_name
                            )
                        )
                    )
                )
            ),
            b(str("vrrp"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    ),
                                    str("microsecond-stamp")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("database") | str("general") | str("interfaces") | str("normal") | str("packets") | str("state") | str("timer") | str("ppm") | str("all"))).as(:oneline)
                        )
                    ),
                    a(str("failover-delay"), arg),
                    a(str("startup-silent-period"), arg),
                    str("asymmetric-hold-time"),
                    b(str("delegate-processing"),
                        c(
                            str("ae-irb")
                        )
                    ),
                    str("skew-timer-disable"),
                    a(str("global-advertisements-threshold"), arg),
                    a(str("inherit-advertisement-interval"), arg),
                    str("version-3")
                )
            ),
            b(str("l2circuit"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("error") | str("topology") | str("fec") | str("connections") | str("oam") | str("egress-protection") | str("auto-sensing") | str("sdb") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("neighbor"), arg),
                        c(
                            b(a(str("interface"), arg),
                                c(
                                    b(str("static"),
                                        c(
                                            a(str("incoming-label"), arg),
                                            a(str("outgoing-label"), arg),
                                            str("send-oam")
                                        )
                                    ),
                                    b(str("psn-tunnel-endpoint"),
                                      ipv4addr
                                    ),
                                    b(str("protect-interface"),
                                      interface_name
                                    ),
                                    a(str("virtual-circuit-id"), arg),
                                    a(str("description"), quote | arg),
                                    str("control-word"),
                                    str("no-control-word"),
                                    str("flow-label-transmit"),
                                    str("flow-label-transmit-static"),
                                    str("flow-label-receive"),
                                    str("flow-label-receive-static"),
                                    a(str("community"), arg),
                                    a(str("mtu"), arg),
                                    b(str("encapsulation-type"),
                                      (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
                                    ),
                                    str("ignore-encapsulation-mismatch"),
                                    str("ignore-mtu-mismatch"),
                                    str("no-revert"),
                                    b(str("bandwidth"),
                                      bandwidth_type
                                    ),
                                    b(str("pseudowire-status-tlv"),
                                        c(
                                            str("hot-standby-vc-on")
                                        )
                                    ),
                                    a(str("switchover-delay"), arg),
                                    b(str("revert-time"),
                                        sc(
                                              arg,
                                            a(str("maximum"), arg)
                                        )
                                    ).as(:oneline),
                                    str("connection-protection"),
                                    b(a(str("backup-neighbor"), arg),
                                        c(
                                            b(str("static"),
                                                c(
                                                    a(str("incoming-label"), arg),
                                                    a(str("outgoing-label"), arg)
                                                )
                                            ),
                                            a(str("virtual-circuit-id"), arg),
                                            a(str("community"), arg),
                                            b(str("psn-tunnel-endpoint"),
                                              ipv4addr
                                            ),
                                            str("standby"),
                                            str("hot-standby")
                                        )
                                    ),
                                    b(str("oam"),
                                        c(
                                            a(str("ping-interval"), arg),
                                            a(str("ping-multiplier"), arg),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    b(str("version"),
                                                      (str("0") | str("1") | str("automatic"))
                                                    ),
                                                    a(str("minimum-interval"), arg),
                                                    a(str("minimum-transmit-interval"), arg),
                                                    a(str("minimum-receive-interval"), arg),
                                                    a(str("multiplier"), arg),
                                                    c(
                                                      str("no-adaptation")
                                                    ),
                                                    b(str("transmit-interval"),
                                                        c(
                                                            a(str("minimum-interval"), arg),
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("detection-time"),
                                                        c(
                                                            a(str("threshold"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("egress-protection"),
                                        c(
                                            c(
                                              b(str("protector-interface"),
                                                interface_name
                                              ),
                                              b(str("protector-pe"),
                                                  sc(
                                                        ipv4addr,
                                                      b(str("context-identifier"),
                                                        ipv4addr
                                                      ),
                                                      a(str("lsp"), arg)
                                                  )
                                              ).as(:oneline)
                                            ),
                                            b(str("protected-l2circuit"),
                                                sc(
                                                    arg,
                                                    b(str("ingress-pe"),
                                                      ipv4addr
                                                    ),
                                                    b(str("egress-pe"),
                                                      ipv4addr
                                                    ),
                                                    a(str("virtual-circuit-id"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("local-switching"),
                        c(
                            b(a(str("interface"), arg),
                                c(
                                    str("no-revert"),
                                    b(str("protect-interface"),
                                      interface_name
                                    ),
                                    str("connection-protection"),
                                    b(a(str("neighbor"), arg),
                                        c(
                                            a(str("virtual-circuit-id"), arg),
                                            a(str("community"), arg),
                                            b(str("psn-tunnel-endpoint"),
                                              ipv4addr
                                            ),
                                            a(str("mtu"), arg)
                                        )
                                    ),
                                    b(a(str("backup-neighbor"), arg),
                                        c(
                                            a(str("virtual-circuit-id"), arg),
                                            b(str("psn-tunnel-endpoint"),
                                              ipv4addr
                                            ),
                                            a(str("community"), arg),
                                            a(str("mtu"), arg)
                                        )
                                    ),
                                    b(str("end-interface"),
                                        c(
                                            b(str("interface"),
                                              interface_name
                                            ),
                                            str("no-revert"),
                                            b(str("protect-interface"),
                                              interface_name
                                            ),
                                            b(str("backup-interface"),
                                              interface_name
                                            )
                                        )
                                    ),
                                    a(str("description"), quote | arg),
                                    b(str("encapsulation-type"),
                                      (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
                                    ),
                                    str("ignore-encapsulation-mismatch"),
                                    str("ignore-mtu-mismatch")
                                )
                            )
                        )
                    ),
                    b(str("auto-sensing"),
                        c(
                            b(str("password"),
                              unreadable
                            )
                        )
                    )
                )
            ),
            b(str("evpn"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("error") | str("topology") | str("nlri") | str("connections") | str("automatic-site") | str("oam") | str("mac-database") | str("nsr") | str("egress-protection") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    str("es-import-oldstyle"),
                    str("es-label-oldstyle"),
                    a(str("mac-history"), arg),
                    b(a(str("mac-list"), arg),
                        c(
                            b(str("mac-address"),
                              mac_addr
                            )
                        )
                    ),
                    b(str("vni-options"),
                      juniper_protocols_vni_options
                    ),
                    b(str("encapsulation"),
                      (str("mpls") | str("vxlan"))
                    ),
                    a(str("extended-vlan-list"), arg),
                    b(str("multicast-mode"),
                      (str("ingress-replication"))
                    ),
                    b(str("assisted-replication"),
                        c(
                            c(
                              b(str("leaf"),
                                  c(
                                      a(str("replicator-activation-delay"), arg)
                                  )
                              ),
                              b(str("replicator"),
                                  c(
                                      c(
                                        b(str("inet"),
                                            c(
                                                  ipv4addr
                                            )
                                        )
                                      ),
                                      b(str("vxlan-encapsulation-source-ip"),
                                        (str("ingress-replication-ip"))
                                      )
                                  )
                              )
                            )
                        )
                    ),
                    b(str("default-gateway"),
                      (str("advertise") | str("no-gateway-community") | str("do-not-advertise"))
                    ),
                    a(str("designated-forwarder-election-hold-time"), arg),
                    a(str("extended-vni-list"), arg),
                    b(str("duplicate-mac-detection"),
                        c(
                            a(str("detection-threshold"), arg),
                            a(str("detection-window"), arg),
                            a(str("auto-recovery-time"), arg)
                        )
                    ),
                    b(str("mac-mobility"),
                        c(
                            str("no-sequence-numbers")
                        )
                    ),
                    str("no-core-isolation"),
                    b(str("remote-ip-host-routes"),
                        c(
                            b(str("import"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            b(str("link-management"),
              juniper_protocols_lmp
            ),
            b(str("pgm"),
              juniper_protocols_pgm
            ),
            b(str("mvpn"),
              juniper_protocols_mvpn
            ),
            b(str("vpls"),
                c(
                    b(str("static-vpls"),
                        c(
                            str("no-tunnel-services")
                        )
                    )
                )
            ),
            b(str("source-packet-routing"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("controller") | str("state") | str("route") | str("general") | str("interface") | str("dtm") | str("bfd") | str("translation") | str("telemetry-statistics") | str("compute") | str("all"))).as(:oneline)
                        )
                    ),
                    a(str("lsp-external-controller"), arg),
                    a(str("preference"), arg),
                    a(str("sr-preference-override"), arg),
                    a(str("sr-preference"), arg),
                    a(str("maximum-segment-list-depth"), arg),
                    b(a(str("segment-list"), arg),
                        c(
                            str("inherit-label-nexthops"),
                            c(
                              b(str("auto-translate"),
                                  c(
                                      c(
                                        b(str("protected"),
                                            c(
                                                str("mandatory")
                                            )
                                        ),
                                        b(str("unprotected"),
                                            c(
                                                str("mandatory")
                                            )
                                        )
                                      )
                                  )
                              ),
                              b(str("dynamic"),
                                  c(
                                      c(
                                        b(str("protected"),
                                            c(
                                                str("mandatory")
                                            )
                                        ),
                                        b(str("unprotected"),
                                            c(
                                                str("mandatory")
                                            )
                                        )
                                      )
                                  )
                              )
                            ),
                            str("compute"),
                                c(
                                    a(str("label"), arg),
                                    b(str("ip-address"),
                                      ipaddr
                                    ),
                                    c(
                                      str("strict"),
                                      str("loose")
                                    ),
                                    b(str("label-type"),
                                        c(
                                            str("node")
                                        )
                                    )
                                )
                        )
                    ),
                    b(a(str("compute-profile"), arg),
                        c(
                            b(str("admin-group"),
                              admin_group_include_exclude
                            ),
                            a(str("maximum-segment-list-depth"), arg),
                            str("no-label-stack-compression"),
                            c(
                              b(str("protected"),
                                  c(
                                      str("mandatory")
                                  )
                              ),
                              b(str("unprotected"),
                                  c(
                                      str("mandatory")
                                  )
                              )
                            ),
                            a(str("compute-segment-list"), arg),
                            a(str("maximum-computed-segment-lists"), arg),
                            b(str("metric-type"),
                                c(
                                    c(
                                      str("te"),
                                      str("igp")
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("source-routing-path"), arg),
                        c(
                            str("ldp-tunneling"),
                            b(str("to"),
                              ipaddr
                            ),
                            a(str("color"), arg),
                            str("no-ingress"),
                            a(str("binding-sid"), arg),
                            a(str("install"), arg).as(:oneline),
                            a(str("preference"), arg),
                            a(str("metric"), arg),
                            a(str("sr-preference"), arg),
                            b(a(str("primary"), arg),
                                c(
                                    a(str("weight"), arg),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("sbfd"),
                                                c(
                                                    a(str("remote-discriminator"), arg)
                                                )
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("multiplier"), arg),
                                            str("no-router-alert-option")
                                        )
                                    ),
                                    b(str("compute"),
                                        c(
                                              arg
                                        )
                                    )
                                )
                            ),
                            b(a(str("secondary"), arg),
                                c(
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("sbfd"),
                                                c(
                                                    a(str("remote-discriminator"), arg)
                                                )
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("multiplier"), arg),
                                            str("no-router-alert-option")
                                        )
                                    ),
                                    b(str("compute"),
                                        c(
                                              arg
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("source-routing-path-template"), arg),
                        c(
                            str("no-ingress"),
                            a(str("metric"), arg),
                            a(str("sr-preference"), arg),
                            str("ldp-tunneling"),
                            b(a(str("primary"), arg),
                                c(
                                    a(str("weight"), arg)
                                )
                            ),
                            a(str("secondary"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("sbfd"),
                                        c(
                                            a(str("remote-discriminator"), arg)
                                        )
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("multiplier"), arg),
                                    str("no-router-alert-option")
                                )
                            )
                        )
                    ),
                    str("inherit-label-nexthops"),
                    b(str("telemetry"),
                        c(
                            b(str("statistics"),
                                c(
                                    str("no-transit"),
                                    str("no-ingress")
                                )
                            )
                        )
                    ),
                    a(str("retry-timer"), arg),
                    str("import-color-only-cross-af"),
                    str("inet6-color-append-explicit-null"),
                    b(str("source-routing-path-template-map"),
                        c(
                            b(str("policy"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            b(str("bgp"),
              juniper_protocols_bgp
            ),
            b(str("router-discovery"),
              juniper_protocols_router_discovery
            ),
            b(str("ldp"),
              juniper_protocols_ldp
            ),
            b(str("mpls"),
              juniper_protocols_mpls
            ),
            b(str("ospf3"),
              juniper_protocols_ospf3
            ),
            b(str("l2-learning"),
              juniper_protocols_bridge
            ),
            b(str("dcbx"),
                c(
                    str("disable"),
                    a(str("interface"), str("all") | arg,
                        c(
                            str("disable"),
                            a(str("application-map"), arg),
                            b(str("applications"),
                                c(
                                    str("no-auto-negotiation")
                                )
                            ),
                            b(str("enhanced-transmission-selection"),
                                c(
                                    str("no-auto-negotiation"),
                                    str("no-recommendation-tlv"),
                                    b(str("recommendation-tlv"),
                                        c(
                                            str("no-auto-negotiation")
                                        )
                                    )
                                )
                            ),
                            a(str("dcbx-version"), str("auto-negotiate") | str("ieee-dcbx") | str("dcbx-version-1.01")),
                            b(str("priority-flow-control"),
                                c(
                                    str("no-auto-negotiation")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("lldp"),
                c(
                      (str("disable")),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("all") | str("configuration") | str("rtsock") | str("packet") | str("protocol") | str("interface") | str("vlan") | str("snmp") | str("jvision")),
                                sc(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("management-address"),
                      ipaddr
                    ),
                    a(str("advertisement-interval"), arg),
                    a(str("transmit-delay"), arg),
                    a(str("hold-multiplier"), arg),
                    a(str("ptopo-configuration-trap-interval"), arg),
                    a(str("ptopo-configuration-maximum-hold-time"), arg),
                    a(str("lldp-configuration-notification-interval"), arg),
                    b(str("port-id-subtype"),
                      (str("locally-assigned") | str("interface-name"))
                    ),
                    b(str("port-description-type"),
                      (str("interface-alias") | str("interface-description"))
                    ),
                    b(str("neighbour-port-info-display"),
                      (str("port-id") | str("port-description"))
                    ),
                    str("mau-type"),
                    b(str("vlan-name-tlv-option"),
                      (str("vlan-id") | arg)
                    ),
                    b(str("tlv-select"),
                          enum((str("port-description") | str("system-name") | str("system-description") | str("system-capabilities") | str("management-address") | str("mac-phy-config-status") | str("power-vi-mdi") | str("link-aggregation") | str("maximum-frame-size") | str("jnpr-chassis-serial") | str("jnpr-vcp") | str("jnpr-mode-change") | str("jnpr-mode-change-error") | str("jnpr-mode-change-ip-address") | str("jnpr-mode-change-image-name") | str("jnpr-mode-change-ftp-login") | str("jnpr-mode-change-image-md5") | str("jnpr-mode-change-ftp-server") | str("port-vid") | str("port-protocol-vid") | str("vlan-name") | str("protocol-id") | str("evb") | str("power-via-mdi-measurements")))
                    ),
                    b(str("tlv-filter"),
                          enum((str("all") | str("port-description") | str("system-name") | str("system-description") | str("system-capabilities") | str("management-address") | str("mac-phy-config-status") | str("power-vi-mdi") | str("link-aggregation") | str("maximum-frame-size") | str("jnpr-chassis-serial") | str("jnpr-vcp") | str("jnpr-mode-change") | str("jnpr-mode-change-error") | str("jnpr-mode-change-ip-address") | str("jnpr-mode-change-image-name") | str("jnpr-mode-change-ftp-login") | str("jnpr-mode-change-image-md5") | str("jnpr-mode-change-ftp-server") | str("port-vid") | str("port-protocol-vid") | str("vlan-name") | str("protocol-id") | str("evb") | str("power-via-mdi-measurements")))
                    ),
                    a(str("interface"), str("all") | arg,
                        c(
                              (str("disable")),
                            b(str("power-negotiation"),
                                c(
                                      (str("disable"))
                                )
                            ),
                            b(str("tlv-select"),
                                  enum((str("port-description") | str("system-name") | str("system-description") | str("system-capabilities") | str("management-address") | str("mac-phy-config-status") | str("power-vi-mdi") | str("link-aggregation") | str("maximum-frame-size") | str("jnpr-chassis-serial") | str("jnpr-vcp") | str("jnpr-mode-change") | str("jnpr-mode-change-error") | str("jnpr-mode-change-ip-address") | str("jnpr-mode-change-image-name") | str("jnpr-mode-change-ftp-login") | str("jnpr-mode-change-image-md5") | str("jnpr-mode-change-ftp-server") | str("port-vid") | str("port-protocol-vid") | str("vlan-name") | str("protocol-id") | str("evb") | str("power-via-mdi-measurements")))
                            ),
                            b(str("tlv-filter"),
                                  enum((str("all") | str("port-description") | str("system-name") | str("system-description") | str("system-capabilities") | str("management-address") | str("mac-phy-config-status") | str("power-vi-mdi") | str("link-aggregation") | str("maximum-frame-size") | str("jnpr-chassis-serial") | str("jnpr-vcp") | str("jnpr-mode-change") | str("jnpr-mode-change-error") | str("jnpr-mode-change-ip-address") | str("jnpr-mode-change-image-name") | str("jnpr-mode-change-ftp-login") | str("jnpr-mode-change-image-md5") | str("jnpr-mode-change-ftp-server") | str("port-vid") | str("port-protocol-vid") | str("vlan-name") | str("protocol-id") | str("evb") | str("power-via-mdi-measurements")))
                            ),
                            b(str("trap-notification"),
                              (str("enable") | str("disable"))
                            )
                        )
                    )
                )
            ),
            b(str("lldp-med"),
                c(
                    a(str("fast-start"), arg),
                    a(str("interface"), str("all") | arg,
                        c(
                              (str("disable")),
                            b(str("location"),
                                c(
                                    c(
                                      b(str("civic-based"),
                                        civic_address_elements
                                      ),
                                      a(str("elin"), arg),
                                      b(str("co-ordinate"),
                                        co_ordinate_elements
                                      )
                                    )
                                )
                            ),
                            b(str("tlv-select"),
                                  enum((str("med-capabilities") | str("network-policy") | str("location-id") | str("ext-power-via-mdi")))
                            ),
                            b(str("tlv-filter"),
                                  enum((str("all") | str("med-capabilities") | str("network-policy") | str("location-id") | str("ext-power-via-mdi")))
                            )
                        )
                    ),
                    b(str("tlv-select"),
                          enum((str("med-capabilities") | str("network-policy") | str("location-id") | str("ext-power-via-mdi")))
                    ),
                    b(str("tlv-filter"),
                          enum((str("all") | str("med-capabilities") | str("network-policy") | str("location-id") | str("ext-power-via-mdi")))
                    ),
                    str("disable")
                )
            ),
            b(str("igmp-snooping"),
              juniper_default_ri_protocols_igmp_snooping
            ),
            b(str("mld-snooping"),
              juniper_default_ri_protocols_mld_snooping
            ),
            b(str("pcep"),
                c(
                    a(str("message-rate-limit"), arg),
                    a(str("update-rate-limit"), arg),
                    a(str("max-provisioned-lsps"), arg),
                    b(a(str("pce-group"), arg),
                        c(
                            b(str("pce-type"),
                                sc(
                                    str("active"),
                                    c(
                                      str("stateful")
                                    )
                                )
                            ).as(:oneline),
                            str("lsp-provisioning"),
                            str("p2mp-lsp-report-capability"),
                            str("p2mp-lsp-update-capability"),
                            str("p2mp-lsp-init-capability"),
                            a(str("lsp-cleanup-timer"), arg),
                            str("spring-capability"),
                            a(str("max-sid-depth"), arg),
                            str("lsp-retry-delegation"),
                            a(str("lsp-retry-delegation-timer"), arg),
                            a(str("request-timer"), arg),
                            a(str("max-unknown-requests"), arg),
                            a(str("max-unknown-messages"), arg),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("pcep") | str("all"))).as(:oneline)
                                )
                            ),
                            a(str("delegation-cleanup-timeout"), arg)
                        )
                    ),
                    b(a(str("pce"), arg),
                        c(
                            b(str("local-address"),
                              ipv4addr
                            ),
                            b(str("destination-ipv4-address"),
                              ipv4addr
                            ),
                            a(str("destination-port"), arg),
                            a(str("delegation-priority"), arg),
                            a(str("request-priority"), arg),
                            a(str("pce-group"), arg),
                            a(str("authentication-key"), arg),
                            b(str("authentication-algorithm"),
                              (str("md5"))
                            ),
                            a(str("authentication-key-chain"), arg),
                            b(str("pce-type"),
                                sc(
                                    str("active"),
                                    c(
                                      str("stateful")
                                    )
                                )
                            ).as(:oneline),
                            str("lsp-provisioning"),
                            str("p2mp-lsp-report-capability"),
                            str("p2mp-lsp-update-capability"),
                            str("p2mp-lsp-init-capability"),
                            a(str("lsp-cleanup-timer"), arg),
                            str("spring-capability"),
                            a(str("max-sid-depth"), arg),
                            str("lsp-retry-delegation"),
                            a(str("lsp-retry-delegation-timer"), arg),
                            a(str("request-timer"), arg),
                            a(str("max-unknown-requests"), arg),
                            a(str("max-unknown-messages"), arg),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("pcep") | str("all"))).as(:oneline)
                                )
                            ),
                            a(str("delegation-cleanup-timeout"), arg)
                        )
                    ),
                    b(str("traceoptions"),
                      pccd_traceoptions_type
                    )
                )
            ),
            b(str("ppp"),
                c(
                    b(str("traceoptions"),
                      ppp_traceoptions_type
                    ),
                    b(str("monitor-session"),
                        s(
                                (str("all") | arg)
                        )
                    )
                )
            ),
            b(str("pppoe"),
                c(
                    b(str("traceoptions"),
                      pppoe_traceoptions_type
                    ),
                    str("pado-advertise"),
                    b(a(str("service-name-tables"), arg),
                        c(
                            b(str("empty-service"),
                                c(
                                    c(
                                      str("terminate"),
                                      str("drop"),
                                      a(str("delay"), arg)
                                    )
                                )
                            ),
                            b(a(str("service"), arg),
                                c(
                                    c(
                                      str("terminate"),
                                      str("drop"),
                                      a(str("delay"), arg)
                                    ),
                                    a(str("dynamic-profile"), arg),
                                    a(str("routing-instance"), arg),
                                    a(str("max-sessions"), arg),
                                    b(str("agent-specifier"),
                                        s(
                                          a(str("aci"), arg),
                                          a(str("ari"), arg),
                                          c(
                                            c(
                                              str("terminate"),
                                              str("drop"),
                                              a(str("delay"), arg)
                                            ),
                                            a(str("dynamic-profile"), arg),
                                            a(str("routing-instance"), arg),
                                            b(str("static-interface"),
                                              interface_unit
                                            )
                                          )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("r2cp"),
                c(
                      (str("disable")),
                    b(str("traceoptions"),
                      r2cp_traceoptions_type
                    ),
                    a(str("server-port"), arg),
                    b(str("client-port"),
                        sc(
                            ca(
                              c(
                                str("any")
                              )
                            )
                        )
                    ).as(:oneline),
                    a(str("node-terminate-count"), arg),
                    a(str("node-terminate-interval"), arg),
                    a(str("session-terminate-count"), arg),
                    a(str("session-terminate-interval"), arg),
                    b(a(str("radio"), arg),
                        c(
                            b(str("interface"),
                              interface_unit
                            ),
                            a(str("down-count"), arg),
                            a(str("virtual-channel-group"), arg),
                            a(str("radio-interface"), arg)
                        )
                    )
                )
            ),
            b(str("sflow"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("configuration") | str("rtsock") | str("interface") | str("client-server") | str("all")),
                                sc(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("agent-id"),
                        sc(
                              ipv4addr,
                            b(str("inet6"),
                              ipv6addr
                            )
                        )
                    ).as(:oneline),
                    a(str("polling-interval"), arg),
                    b(str("adaptive-sample-rate"),
                        sc(
                              arg,
                            str("fallback"),
                            a(str("sample-limit-threshold"), arg)
                        )
                    ).as(:oneline),
                    str("inline-sampling"),
                    b(str("sample-rate"),
                        c(
                            a(str("ingress"), arg),
                            a(str("egress"), arg)
                        )
                    ),
                    b(str("source-ip"),
                        sc(
                              ipv4addr,
                            b(str("inet6"),
                              ipv6addr
                            )
                        )
                    ).as(:oneline),
                    b(a(str("collector"), arg),
                        c(
                            a(str("udp-port"), arg),
                            a(str("dscp"), arg),
                            a(str("forwarding-class"), arg)
                        )
                    ),
                    b(a(str("interfaces"), arg),
                        c(
                            a(str("polling-interval"), arg),
                            b(str("sample-rate"),
                                c(
                                    a(str("ingress"), arg),
                                    a(str("egress"), arg)
                                )
                            )
                        )
                    ),
                    str("disable-sw-rate-limiter")
                )
            ),
            b(str("layer2-control"),
              juniper_protocols_l2control
            ),
            b(str("rstp"),
              juniper_protocols_stp
            ),
            b(str("mstp"),
              juniper_protocols_mstp
            ),
            b(str("vstp"),
              juniper_protocols_vstp
            ),
            b(str("loop-detect"),
                c(
                    a(str("interface"), str("all-extended-ports") | arg,
                        c(
                            str("disable")
                        )
                    ),
                    b(str("destination-mac"),
                      mac_multicast
                    ),
                    a(str("transmit-interval"), arg)
                )
            ),
            b(str("protection-group"),
              juniper_protocols_protection_group
            ),
            b(str("mvrp"),
              juniper_protocols_mvrp
            ),
            b(str("ovsdb"),
              juniper_protocols_vgd
            ),
            b(str("openflow"),
              juniper_protocols_openflow
            )
        )
    end

    rule(:admin_group_include_exclude) do
        c(
            c(
              a(str("include-any"), arg)
            ),
            c(
              a(str("include-all"), arg)
            ),
            c(
              a(str("exclude"), arg)
            )
        )
    end

    rule(:bandwidth_type) do
        ca(
            a(str("ct0"), arg),
            a(str("ct1"), arg),
            a(str("ct2"), arg),
            a(str("ct3"), arg)
        )
    end

    rule(:civic_address_elements) do
        c(
            a(str("what"), arg),
            a(str("country-code"), arg),
            b(a(str("ca-type"), arg),
                c(
                    a(str("ca-value"), arg)
                )
            )
        )
    end

    rule(:clksync_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("init") | str("routing-socket") | str("synchronization") | str("ptp") | str("protocol") | str("configuration") | str("debug") | str("ppm") | str("error") | str("hybrid") | str("framer") | str("ipc") | str("all"))).as(:oneline)
        )
    end

    rule(:co_ordinate_elements) do
        c(
            a(str("longitude"), arg),
            a(str("lattitude"), arg)
        )
    end

    rule(:juniper_default_ri_protocols_igmp_snooping) do
        c(
            a(str("vlan"), str("all") | arg,
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("group") | str("client-notification") | str("route") | str("normal") | str("general") | str("state") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("query-interval"), arg),
                    b(str("l2-querier"),
                        c(
                            b(str("source-address"),
                              ipv4addr
                            )
                        )
                    ),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    b(str("proxy"),
                        c(
                            b(str("source-address"),
                              ipv4addr
                            )
                        )
                    ),
                    str("evpn-ssm-reports-only"),
                    b(str("data-forwarding"),
                        c(
                            c(
                              b(str("source"),
                                  c(
                                      b(str("groups"),
                                        ipv4prefix
                                      )
                                  )
                              ),
                              b(str("receiver"),
                                  c(
                                      c(
                                        str("translate")
                                      ),
                                      a(str("source-list"), arg),
                                      str("install"),
                                      b(str("mode"),
                                        (str("transparent") | str("proxy"))
                                      )
                                  )
                              )
                            )
                        )
                    ),
                    b(a(str("interface"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave"),
                            str("host-only-interface"),
                            a(str("group-limit"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            a(str("source"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("qualified-vlan"), arg),
                        c(
                            a(str("query-interval"), arg),
                            b(str("l2-querier"),
                                c(
                                    b(str("source-address"),
                                      ipv4addr
                                    )
                                )
                            ),
                            a(str("query-response-interval"), arg),
                            a(str("query-last-member-interval"), arg),
                            a(str("robust-count"), arg),
                            str("immediate-leave"),
                            b(str("proxy"),
                                c(
                                    b(str("source-address"),
                                      ipv4addr
                                    )
                                )
                            ),
                            str("evpn-ssm-reports-only"),
                            b(a(str("interface"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave"),
                                    str("host-only-interface"),
                                    a(str("group-limit"), arg),
                                    b(str("static"),
                                        c(
                                            b(a(str("group"), arg),
                                                c(
                                                    a(str("source"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("disable")
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("query-interval"), arg),
            a(str("query-response-interval"), arg),
            a(str("query-last-member-interval"), arg),
            a(str("robust-count"), arg),
            str("immediate-leave"),
            b(str("proxy"),
                c(
                    b(str("source-address"),
                      ipv4addr
                    ),
                    str("irb")
                )
            ),
            str("evpn-ssm-reports-only"),
            b(a(str("interface"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave"),
                    str("host-only-interface"),
                    a(str("group-limit"), arg),
                    b(str("static"),
                        c(
                            b(a(str("group"), arg),
                                c(
                                    a(str("source"), arg)
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_default_ri_protocols_mld_snooping) do
        c(
            a(str("vlan"), str("all") | arg,
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("query-interval"), arg),
                    b(str("l2-querier"),
                        c(
                            b(str("source-address"),
                              ipv6addr
                            )
                        )
                    ),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    str("evpn-ssm-reports-only"),
                    b(a(str("interface"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave"),
                            str("host-only-interface"),
                            a(str("group-limit"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            a(str("source"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("qualified-vlan"), arg),
                        c(
                            a(str("query-interval"), arg),
                            b(str("l2-querier"),
                                c(
                                    b(str("source-address"),
                                      ipv6addr
                                    )
                                )
                            ),
                            a(str("query-response-interval"), arg),
                            a(str("query-last-member-interval"), arg),
                            a(str("robust-count"), arg),
                            str("immediate-leave"),
                            str("evpn-ssm-reports-only"),
                            b(a(str("interface"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave"),
                                    str("host-only-interface"),
                                    a(str("group-limit"), arg),
                                    b(str("static"),
                                        c(
                                            b(a(str("group"), arg),
                                                c(
                                                    a(str("source"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("query-interval"), arg),
            a(str("query-response-interval"), arg),
            a(str("query-last-member-interval"), arg),
            a(str("robust-count"), arg),
            str("immediate-leave"),
            b(str("proxy"),
                c(
                    b(str("source-address"),
                      ipv6addr
                    ),
                    str("irb")
                )
            ),
            str("evpn-ssm-reports-only"),
            b(a(str("interface"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave"),
                    str("host-only-interface"),
                    a(str("group-limit"), arg),
                    b(str("static"),
                        c(
                            b(a(str("group"), arg),
                                c(
                                    a(str("source"), arg)
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_amt) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("errors") | str("tunnels") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("relay"),
              juniper_protocols_amt_relay
            )
        )
    end

    rule(:juniper_protocols_amt_relay) do
        c(
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            b(str("anycast-prefix"),
                              ipv4prefix
                            ),
                            b(str("local-address"),
                              ipv4addr
                            )
                        )
                    )
                )
            ),
            a(str("secret-key-timeout"), arg),
            a(str("tunnel-limit"), arg),
            a(str("unicast-stream-limit"), arg),
            str("accounting"),
            b(str("tunnel-devices"),
              interface_device
            )
        )
    end

    rule(:juniper_protocols_ancp) do
        c(
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    b(str("level"),
                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                    ),
                    a(str("flag"), enum(str("config") | str("cos") | str("routing-socket") | str("packet") | str("protocol") | str("process") | str("startup") | str("session") | str("general") | str("restart") | str("subscriber") | str("timer") | str("all")),
                        sc(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("qos-adjust"),
                c(
                    a(str("sdsl-bytes"), arg),
                    a(str("sdsl-overhead-adjust"), arg),
                    a(str("vdsl-bytes"), arg),
                    a(str("vdsl-overhead-adjust"), arg),
                    a(str("vdsl2-bytes"), arg),
                    a(str("vdsl2-overhead-adjust"), arg),
                    a(str("adsl-bytes"), arg),
                    a(str("adsl2-bytes"), arg),
                    a(str("adsl2-plus-bytes"), arg),
                    a(str("other-bytes"), arg),
                    a(str("other-overhead-adjust"), arg)
                )
            ),
            str("pre-ietf-mode"),
            a(str("maximum-discovery-table-entries"), arg),
            a(str("adjacency-timer"), arg),
            a(str("maximum-helper-restart-time"), arg),
            a(str("qos-adjust-adsl"), arg),
            a(str("qos-adjust-adsl2"), arg),
            a(str("qos-adjust-adsl2-plus"), arg),
            a(str("qos-adjust-vdsl"), arg),
            a(str("qos-adjust-vdsl2"), arg),
            a(str("qos-adjust-sdsl"), arg),
            a(str("qos-adjust-other"), arg),
            str("gsmp-syn-wait"),
            a(str("gsmp-syn-timeout"), arg),
            a(str("adjacency-loss-hold-time"), arg),
            b(str("interfaces"),
                c(
                    b(a(str("interface-set"), arg),
                        c(
                            a(str("access-identifier"), arg),
                            b(str("neighbor"),
                              ipaddr
                            )
                        )
                    ),
                      ancp_interfaces_type
                )
            ),
            b(a(str("neighbor"), arg),
                c(
                    str("discovery-mode"),
                    c(
                      str("pre-ietf-mode"),
                      str("ietf-mode")
                    ),
                    a(str("adjacency-timer"), arg),
                    a(str("maximum-discovery-table-entries"), arg),
                    b(str("auto-configure-trigger"),
                        c(
                            b(str("interface"),
                              interface_device
                            )
                        )
                    ),
                    a(str("adjacency-loss-hold-time"), arg)
                )
            )
        )
    end

    rule(:ancp_interfaces_type) do
      b(arg.as(:arg),
        c(
            a(str("access-identifier"), arg),
            b(str("neighbor"),
              ipaddr
            ),
            str("overhead-accounting")
        )
      )
    end

    rule(:juniper_protocols_bd) do
        c(
            b(str("mac-table-size"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop"))
                    )
                )
            ),
            b(str("mac-ip-table-size"),
                c(
                      arg
                )
            ),
            b(str("interface-mac-limit"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                    )
                )
            ),
            b(str("interface-mac-ip-limit"),
                c(
                      arg
                )
            ),
            b(str("mac-notification"),
                c(
                    a(str("notification-interval"), arg)
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("no-normalization"),
            str("mac-statistics"),
            b(str("mib"),
                c(
                    b(str("dot1q-mib"),
                        c(
                            b(str("port-list"),
                              (str("bit-map") | str("string"))
                            )
                        )
                    )
                )
            ),
            b(str("static-rvtep-mac"),
                c(
                    b(str("mac"),
                        s(
                                arg,
                          a(str("remote-vtep"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        ca(
                            str("disable"),
                            b(str("packet-action"),
                              (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                            )
                        )
                    ),
                    b(str("vpws-service-id"),
                        c(
                            a(str("local"), arg),
                            a(str("remote"), arg)
                        )
                    ),
                    b(str("protect-interface"),
                      interface_name
                    ),
                    a(str("action-priority"), arg),
                    a(str("remote-site-id"), arg),
                    a(str("target-attachment-identifier"), arg),
                    str("flow-label-transmit"),
                    str("flow-label-receive"),
                    b(str("encapsulation-type"),
                      (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
                    ),
                    str("ignore-encapsulation-mismatch"),
                    a(str("mtu"), arg),
                    str("ignore-mtu-mismatch"),
                    c(
                      str("control-word"),
                      str("no-control-word")
                    ),
                    str("pseudowire-status-tlv"),
                    b(str("oam"),
                        c(
                            a(str("ping-interval"), arg),
                            a(str("ping-multiplier"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("community"), arg),
                    b(a(str("static-mac"), arg),
                        c(
                            a(str("vlan-id"), arg)
                        )
                    ),
                    b(str("interface-mac-ip-limit"),
                        c(
                              arg
                        )
                    ),
                    str("no-mac-learning"),
                    str("mac-pinning"),
                    a(str("description"), quote | arg),
                    str("persistent-learning")
                )
            )
        )
    end

    rule(:juniper_protocols_bgp) do
        c(
            b(str("path-selection"),
                c(
                    str("l2vpn-use-bgp-rules"),
                    str("cisco-non-deterministic"),
                    str("always-compare-med"),
                    b(str("med-plus-igp"),
                        c(
                            a(str("med-multiplier"), arg),
                            a(str("igp-multiplier"), arg)
                        )
                    ),
                    str("external-router-id"),
                    str("as-path-ignore")
                )
            ),
            str("advertise-from-main-vpn-tables"),
            a(str("stale-labels-holddown-period"), arg),
            str("holddown-all-stale-labels"),
            b(str("egress-te-backup-paths"),
                c(
                    b(a(str("template"), arg),
                        c(
                            a(str("peer"), arg),
                            b(str("remote-nexthop"),
                                c(
                                      ipaddr
                                )
                            ),
                            b(str("ip-forward"),
                                c(
                                    arg
                                )
                            )
                        )
                    )
                )
            ),
            a(str("sr-preference-override"), arg),
            str("vpn-apply-export"),
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            b(str("labeled-unicast"),
                              bgp_afi_labeled
                            ),
                            b(str("segment-routing-te"),
                              bgp_afi_srte
                            ),
                            b(str("unicast"),
                              bgp_afi_topo
                            ),
                            b(str("multicast"),
                              bgp_afi_default
                            ),
                            b(str("flow"),
                              bgp_afi_flow_with_redirect_ip_action
                            ),
                            b(str("any"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("inet-vpn"),
                        c(
                            b(str("unicast"),
                              bgp_afi_l3vpn
                            ),
                            b(str("multicast"),
                              bgp_afi_vpn
                            ),
                            b(str("flow"),
                              bgp_afi_flow_with_redirect_ip_action
                            ),
                            b(str("any"),
                              bgp_afi_vpn
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                            b(str("labeled-unicast"),
                              bgp_afi_inet6_labeled
                            ),
                            b(str("segment-routing-te"),
                              bgp_afi_srte
                            ),
                            b(str("unicast"),
                              bgp_afi_topo
                            ),
                            b(str("multicast"),
                              bgp_afi_default
                            ),
                            b(str("flow"),
                              bgp_afi_flow
                            ),
                            b(str("any"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("inet6-vpn"),
                        c(
                            b(str("unicast"),
                              bgp_afi_l3vpn
                            ),
                            b(str("multicast"),
                              bgp_afi_vpn
                            ),
                            b(str("flow"),
                              bgp_afi_flow
                            ),
                            b(str("any"),
                              bgp_afi_vpn
                            )
                        )
                    ),
                    b(str("iso-vpn"),
                        c(
                            b(str("unicast"),
                              bgp_afi_vpn_protection
                            )
                        )
                    ),
                    b(str("l2vpn"),
                        c(
                            b(str("auto-discovery-only"),
                              bgp_afi_default
                            ),
                            b(str("auto-discovery-mspw"),
                              bgp_afi_default
                            ),
                            b(str("signaling"),
                              bgp_afi_l2vpn
                            )
                        )
                    ),
                    b(str("evpn"),
                        c(
                            b(str("signaling"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("inet-mvpn"),
                        c(
                            b(str("signaling"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("inet6-mvpn"),
                        c(
                            b(str("signaling"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("inet-mdt"),
                        c(
                            b(str("signaling"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("traffic-engineering"),
                        c(
                            b(str("unicast"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("route-target"),
                        c(
                            b(str("prefix-limit"),
                              bgpaf_prefix_limit
                            ),
                            b(str("accepted-prefix-limit"),
                              bgpaf_accepted_prefix_limit
                            ),
                            b(str("proxy-generate"),
                                c(
                                    b(str("route-target-policy"),
                                      policy_algebra
                                    )
                                )
                            ),
                            a(str("external-paths"), arg),
                            str("advertise-default"),
                            str("damping"),
                            b(str("graceful-restart"),
                              bgp_af_gr
                            ),
                            b(str("local-ipv4-address"),
                              ipv4addr
                            ),
                            b(str("output-queue-priority"),
                              bgp_output_queue_priority_class
                            ),
                            b(str("route-refresh-priority"),
                              bgp_output_queue_priority_class
                            ),
                            b(str("withdraw-priority"),
                              bgp_output_queue_priority_class
                            )
                        )
                    ),
                    b(str("fabric"),
                        c(
                            b(str("unicast"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("bridge"),
                        c(
                            b(str("unicast"),
                              bgp_afi_default
                            )
                        )
                    ),
                    b(str("bridge-vpn"),
                        c(
                            b(str("unicast"),
                              bgp_afi_vpn
                            )
                        )
                    ),
                    b(str("fabric-vpn"),
                        c(
                            b(str("unicast"),
                              bgp_afi_vpn
                            )
                        )
                    )
                )
            ),
            b(str("egress-te"),
                c(
                    b(str("install-address"),
                      ipaddr
                    ),
                    b(str("rib"),
                        c(
                            str("inet.0"),
                            str("inet6.0")
                        )
                    ),
                    str("no-install"),
                    b(str("import"),
                      policy_algebra
                    ),
                    a(str("backup-path"), arg)
                )
            ),
            str("egress-te-sid-stats"),
            b(a(str("egress-te-set-segment"), arg),
                c(
                    b(str("label"),
                        c(
                              arg
                        )
                    ),
                    b(str("egress-te-backup-segment"),
                        c(
                            b(str("label"),
                                c(
                                      arg
                                )
                            )
                        )
                    ),
                    b(str("egress-te-backup-ip-forward"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(a(str("group"), arg),
                c(
                    b(str("type"),
                      (str("internal") | str("external"))
                    ),
                    b(str("protocol"),
                      (str("rip") | str("ospf") | str("isis"))
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("damping") | str("packets") | str("open") | str("update") | str("keepalive") | str("refresh") | str("nsr-synchronization") | str("bfd") | str("4byte-as") | str("add-path") | str("graceful-restart") | str("egress-te") | str("thread-io") | str("sharding") | str("thread-update-io") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable"),
                                    b(str("filter"),
                                      bgp_filter_obj
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("description"), quote | arg),
                    b(str("metric-out"),
                        sc(
                            ca(
                              b(str("minimum-igp"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline),
                              b(str("igp"),
                                  sc(
                                      arg,
                                      str("delay-med-update")
                                  )
                              ).as(:oneline),
                              b(str("effective-aigp"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline),
                              b(str("minimum-effective-aigp"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("multihop"),
                        c(
                            a(str("ttl"), arg),
                            str("no-nexthop-change")
                        )
                    ),
                    str("route-server-client"),
                    str("accept-remote-nexthop"),
                    a(str("preference"), arg),
                    a(str("local-preference"), arg),
                    b(str("local-address"),
                      ipaddr
                    ),
                    b(str("local-interface"),
                      interface_name
                    ),
                    a(str("forwarding-context"), arg),
                    a(str("hold-time"), arg),
                    a(str("minimum-hold-time"), arg),
                    str("passive"),
                    str("advertise-inactive"),
                    str("advertise-peer-as"),
                    str("no-advertise-peer-as"),
                    b(str("advertise-external"),
                        sc(
                            str("conditional")
                        )
                    ).as(:oneline),
                    b(str("keep"),
                      (str("all") | str("none"))
                    ),
                    str("rfc6514-compliant-safi129"),
                    str("no-aggregator-id"),
                    str("mtu-discovery"),
                    str("enforce-first-as"),
                    a(str("out-delay"), arg),
                    b(str("ttl"),
                      (str("1") | str("255"))
                    ),
                    str("log-updown"),
                    str("damping"),
                    b(str("import"),
                      policy_algebra
                    ),
                    b(str("nlri"),
                      (str("unicast") | str("multicast") | str("any"))
                    ),
                    b(str("bgp-error-tolerance"),
                        c(
                            a(str("malformed-update-log-interval"), arg),
                            c(
                              a(str("malformed-route-limit"), arg),
                              str("no-malformed-route-limit")
                            )
                        )
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("labeled-unicast"),
                                      bgp_afi_labeled
                                    ),
                                    b(str("segment-routing-te"),
                                      bgp_afi_srte
                                    ),
                                    b(str("unicast"),
                                      bgp_afi_topo
                                    ),
                                    b(str("multicast"),
                                      bgp_afi_default
                                    ),
                                    b(str("flow"),
                                      bgp_afi_flow_with_redirect_ip_action
                                    ),
                                    b(str("any"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("inet-vpn"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_l3vpn
                                    ),
                                    b(str("multicast"),
                                      bgp_afi_vpn
                                    ),
                                    b(str("flow"),
                                      bgp_afi_flow_with_redirect_ip_action
                                    ),
                                    b(str("any"),
                                      bgp_afi_vpn
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("labeled-unicast"),
                                      bgp_afi_inet6_labeled
                                    ),
                                    b(str("segment-routing-te"),
                                      bgp_afi_srte
                                    ),
                                    b(str("unicast"),
                                      bgp_afi_topo
                                    ),
                                    b(str("multicast"),
                                      bgp_afi_default
                                    ),
                                    b(str("flow"),
                                      bgp_afi_flow
                                    ),
                                    b(str("any"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("inet6-vpn"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_l3vpn
                                    ),
                                    b(str("multicast"),
                                      bgp_afi_vpn
                                    ),
                                    b(str("flow"),
                                      bgp_afi_flow
                                    ),
                                    b(str("any"),
                                      bgp_afi_vpn
                                    )
                                )
                            ),
                            b(str("iso-vpn"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_vpn_protection
                                    )
                                )
                            ),
                            b(str("l2vpn"),
                                c(
                                    b(str("auto-discovery-only"),
                                      bgp_afi_default
                                    ),
                                    b(str("auto-discovery-mspw"),
                                      bgp_afi_default
                                    ),
                                    b(str("signaling"),
                                      bgp_afi_l2vpn
                                    )
                                )
                            ),
                            b(str("evpn"),
                                c(
                                    b(str("signaling"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("inet-mvpn"),
                                c(
                                    b(str("signaling"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("inet6-mvpn"),
                                c(
                                    b(str("signaling"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("inet-mdt"),
                                c(
                                    b(str("signaling"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("traffic-engineering"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("route-target"),
                                c(
                                    b(str("prefix-limit"),
                                      bgpaf_prefix_limit
                                    ),
                                    b(str("accepted-prefix-limit"),
                                      bgpaf_accepted_prefix_limit
                                    ),
                                    b(str("proxy-generate"),
                                        c(
                                            b(str("route-target-policy"),
                                              policy_algebra
                                            )
                                        )
                                    ),
                                    a(str("external-paths"), arg),
                                    str("advertise-default"),
                                    str("damping"),
                                    b(str("graceful-restart"),
                                      bgp_af_gr
                                    ),
                                    b(str("local-ipv4-address"),
                                      ipv4addr
                                    ),
                                    b(str("output-queue-priority"),
                                      bgp_output_queue_priority_class
                                    ),
                                    b(str("route-refresh-priority"),
                                      bgp_output_queue_priority_class
                                    ),
                                    b(str("withdraw-priority"),
                                      bgp_output_queue_priority_class
                                    )
                                )
                            ),
                            b(str("fabric"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_default
                                    )
                                )
                            ),
                            b(str("bridge-vpn"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_vpn
                                    )
                                )
                            ),
                            b(str("fabric-vpn"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_vpn
                                    )
                                )
                            )
                        )
                    ),
                    a(str("authentication-key"), arg),
                    b(str("authentication-algorithm"),
                      (str("md5") | str("hmac-sha-1-96") | str("aes-128-cmac-96"))
                    ),
                    a(str("authentication-key-chain"), arg),
                    b(str("export"),
                      policy_algebra
                    ),
                    b(str("remove-private"),
                        c(
                            b(str("all"),
                                sc(
                                    b(str("replace"),
                                        sc(
                                            str("nearest")
                                        )
                                    ).as(:oneline)
                                )
                            ).as(:oneline),
                            str("no-peer-loop-check")
                        )
                    ),
                    b(str("cluster"),
                      areaid
                    ),
                    str("no-client-reflect"),
                    a(str("peer-as"), arg),
                    b(str("local-as"),
                        sc(
                            arg,
                            a(str("loops"), arg),
                            str("private"),
                            str("alias"),
                            str("no-prepend-global-as")
                        )
                    ).as(:oneline),
                    a(str("ipsec-sa"), arg),
                    b(str("graceful-shutdown"),
                        c(
                            b(str("receiver"),
                                c(
                                    str("disable"),
                                    a(str("local-preference"), arg)
                                )
                            ),
                            b(str("sender"),
                                c(
                                    a(str("local-preference"), arg)
                                )
                            )
                        )
                    ),
                    b(str("shutdown"),
                        c(
                            a(str("notify-message"), arg)
                        )
                    ),
                    str("unconfigured-peer-graceful-restart"),
                    b(str("graceful-restart"),
                        c(
                              (str("disable")),
                            a(str("restart-time"), arg),
                            a(str("stale-routes-time"), arg),
                            b(str("long-lived"),
                                c(
                                    b(str("receiver"),
                                        c(
                                              (str("disable"))
                                        )
                                    ),
                                    b(str("advertise-to-non-llgr-neighbor"),
                                        c(
                                            str("omit-no-export")
                                        )
                                    )
                                )
                            ),
                            str("disable-notification-extensions"),
                            b(str("forwarding-state-bit"),
                              (str("as-rr-client") | str("from-fib"))
                            ),
                            str("dont-help-shared-fate-bfd-down")
                        )
                    ),
                    str("include-mp-next-hop"),
                    str("disable-4byte-as"),
                    b(str("idle-after-switch-over"),
                        sc(
                            c(
                              str("forever"),
                                arg
                            )
                        )
                    ).as(:oneline),
                    b(str("outbound-route-filter"),
                        c(
                            str("bgp-orf-cisco-mode"),
                            b(str("extended-community"),
                                c(
                                    str("accept"),
                                    str("no-accept"),
                                    str("vrf-filter")
                                )
                            ),
                            b(str("prefix-based"),
                                c(
                                    b(str("accept"),
                                        c(
                                            str("inet6"),
                                            str("inet")
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("message-batching"),
                        c(
                              (str("enable") | str("disable")),
                            a(str("interval"), arg)
                        )
                    ),
                    b(str("multipath"),
                        c(
                            str("disable"),
                            str("multiple-as"),
                            str("allow-protection")
                        )
                    ),
                    a(str("tcp-mss"), arg),
                    str("tcp-aggressive-transmission"),
                    b(str("bmp"),
                        c(
                            b(str("monitor"),
                              (str("enable") | str("disable"))
                            ),
                            b(str("route-monitoring"),
                                c(
                                    str("none"),
                                    b(str("pre-policy"),
                                        sc(
                                            str("exclude-non-feasible")
                                        )
                                    ).as(:oneline),
                                    b(str("post-policy"),
                                        sc(
                                            str("exclude-non-eligible")
                                        )
                                    ).as(:oneline),
                                    b(str("rib-out"),
                                        sc(
                                            str("pre-policy"),
                                            str("post-policy")
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("advertise-bgp-static"),
                        c(
                            b(str("policy"),
                              policy_algebra
                            )
                        )
                    ),
                    str("add-path-display-ipv4-address"),
                    b(str("bfd-liveness-detection"),
                        c(
                            b(str("version"),
                              (str("0") | str("1") | str("automatic"))
                            ),
                            a(str("minimum-interval"), arg),
                            a(str("minimum-transmit-interval"), arg),
                            a(str("minimum-receive-interval"), arg),
                            a(str("multiplier"), arg),
                            c(
                              str("no-adaptation")
                            ),
                            b(str("transmit-interval"),
                                c(
                                    a(str("minimum-interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("detection-time"),
                                c(
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("authentication"),
                                c(
                                    a(str("key-chain"), arg),
                                    b(str("algorithm"),
                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                    ),
                                    str("loose-check")
                                )
                            ),
                            b(str("session-mode"),
                              (str("automatic") | str("single-hop") | str("multihop"))
                            ),
                            a(str("holddown-interval"), arg)
                        )
                    ),
                    str("as-override"),
                    b(str("allow"),
                      ipprefix
                    ),
                    b(a(str("dynamic-neighbor"), arg),
                        c(
                            b(str("allow"),
                              ipprefix
                            ),
                            a(str("authentication-key"), arg),
                            b(str("authentication-algorithm"),
                              (str("md5") | str("hmac-sha-1-96") | str("aes-128-cmac-96"))
                            ),
                            a(str("authentication-key-chain"), arg)
                        )
                    ),
                    b(str("optimal-route-reflection"),
                        c(
                            b(str("igp-primary"),
                              ipv4addr
                            ),
                            b(str("igp-backup"),
                              ipv4addr
                            )
                        )
                    ),
                    str("mvpn-iana-rt-import"),
                    b(a(str("neighbor"), arg),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("damping") | str("packets") | str("open") | str("update") | str("keepalive") | str("refresh") | str("nsr-synchronization") | str("bfd") | str("4byte-as") | str("add-path") | str("graceful-restart") | str("egress-te") | str("thread-io") | str("sharding") | str("thread-update-io") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                        sc(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable"),
                                            b(str("filter"),
                                              bgp_filter_obj
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            a(str("description"), quote | arg),
                            b(str("metric-out"),
                                sc(
                                    ca(
                                      b(str("minimum-igp"),
                                          sc(
                                              arg
                                          )
                                      ).as(:oneline),
                                      b(str("igp"),
                                          sc(
                                              arg,
                                              str("delay-med-update")
                                          )
                                      ).as(:oneline),
                                      b(str("effective-aigp"),
                                          sc(
                                              arg
                                          )
                                      ).as(:oneline),
                                      b(str("minimum-effective-aigp"),
                                          sc(
                                              arg
                                          )
                                      ).as(:oneline)
                                    )
                                )
                            ).as(:oneline),
                            b(str("multihop"),
                                c(
                                    a(str("ttl"), arg),
                                    str("no-nexthop-change")
                                )
                            ),
                            str("route-server-client"),
                            str("accept-remote-nexthop"),
                            a(str("preference"), arg),
                            a(str("local-preference"), arg),
                            b(str("local-address"),
                              ipaddr
                            ),
                            b(str("local-interface"),
                              interface_name
                            ),
                            a(str("forwarding-context"), arg),
                            a(str("hold-time"), arg),
                            a(str("minimum-hold-time"), arg),
                            str("passive"),
                            str("advertise-inactive"),
                            str("advertise-peer-as"),
                            str("no-advertise-peer-as"),
                            b(str("advertise-external"),
                                sc(
                                    str("conditional")
                                )
                            ).as(:oneline),
                            b(str("keep"),
                              (str("all") | str("none"))
                            ),
                            str("rfc6514-compliant-safi129"),
                            str("no-aggregator-id"),
                            str("mtu-discovery"),
                            str("enforce-first-as"),
                            a(str("out-delay"), arg),
                            b(str("ttl"),
                              (str("1") | str("255"))
                            ),
                            str("log-updown"),
                            str("damping"),
                            b(str("import"),
                              policy_algebra
                            ),
                            b(str("nlri"),
                              (str("unicast") | str("multicast") | str("any"))
                            ),
                            b(str("bgp-error-tolerance"),
                                c(
                                    a(str("malformed-update-log-interval"), arg),
                                    c(
                                      a(str("malformed-route-limit"), arg),
                                      str("no-malformed-route-limit")
                                    )
                                )
                            ),
                            b(str("family"),
                                c(
                                    b(str("inet"),
                                        c(
                                            b(str("labeled-unicast"),
                                              bgp_afi_labeled
                                            ),
                                            b(str("segment-routing-te"),
                                              bgp_afi_srte
                                            ),
                                            b(str("unicast"),
                                              bgp_afi_topo
                                            ),
                                            b(str("multicast"),
                                              bgp_afi_default
                                            ),
                                            b(str("flow"),
                                              bgp_afi_flow_with_redirect_ip_action
                                            ),
                                            b(str("any"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("inet-vpn"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_l3vpn
                                            ),
                                            b(str("multicast"),
                                              bgp_afi_vpn
                                            ),
                                            b(str("flow"),
                                              bgp_afi_flow_with_redirect_ip_action
                                            ),
                                            b(str("any"),
                                              bgp_afi_vpn
                                            )
                                        )
                                    ),
                                    b(str("inet6"),
                                        c(
                                            b(str("labeled-unicast"),
                                              bgp_afi_inet6_labeled
                                            ),
                                            b(str("segment-routing-te"),
                                              bgp_afi_srte
                                            ),
                                            b(str("unicast"),
                                              bgp_afi_topo
                                            ),
                                            b(str("multicast"),
                                              bgp_afi_default
                                            ),
                                            b(str("flow"),
                                              bgp_afi_flow
                                            ),
                                            b(str("any"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("inet6-vpn"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_l3vpn
                                            ),
                                            b(str("multicast"),
                                              bgp_afi_vpn
                                            ),
                                            b(str("flow"),
                                              bgp_afi_flow
                                            ),
                                            b(str("any"),
                                              bgp_afi_vpn
                                            )
                                        )
                                    ),
                                    b(str("iso-vpn"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_vpn_protection
                                            )
                                        )
                                    ),
                                    b(str("l2vpn"),
                                        c(
                                            b(str("auto-discovery-only"),
                                              bgp_afi_default
                                            ),
                                            b(str("auto-discovery-mspw"),
                                              bgp_afi_default
                                            ),
                                            b(str("signaling"),
                                              bgp_afi_l2vpn
                                            )
                                        )
                                    ),
                                    b(str("evpn"),
                                        c(
                                            b(str("signaling"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("inet-mvpn"),
                                        c(
                                            b(str("signaling"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("inet6-mvpn"),
                                        c(
                                            b(str("signaling"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("inet-mdt"),
                                        c(
                                            b(str("signaling"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("traffic-engineering"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("route-target"),
                                        c(
                                            b(str("prefix-limit"),
                                              bgpaf_prefix_limit
                                            ),
                                            b(str("accepted-prefix-limit"),
                                              bgpaf_accepted_prefix_limit
                                            ),
                                            b(str("proxy-generate"),
                                                c(
                                                    b(str("route-target-policy"),
                                                      policy_algebra
                                                    )
                                                )
                                            ),
                                            a(str("external-paths"), arg),
                                            str("advertise-default"),
                                            str("damping"),
                                            b(str("graceful-restart"),
                                              bgp_af_gr
                                            ),
                                            b(str("local-ipv4-address"),
                                              ipv4addr
                                            ),
                                            b(str("output-queue-priority"),
                                              bgp_output_queue_priority_class
                                            ),
                                            b(str("route-refresh-priority"),
                                              bgp_output_queue_priority_class
                                            ),
                                            b(str("withdraw-priority"),
                                              bgp_output_queue_priority_class
                                            )
                                        )
                                    ),
                                    b(str("fabric"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("bridge"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_default
                                            )
                                        )
                                    ),
                                    b(str("bridge-vpn"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_vpn
                                            )
                                        )
                                    ),
                                    b(str("fabric-vpn"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_vpn
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("authentication-key"), arg),
                            b(str("authentication-algorithm"),
                              (str("md5") | str("hmac-sha-1-96") | str("aes-128-cmac-96"))
                            ),
                            a(str("authentication-key-chain"), arg),
                            b(str("export"),
                              policy_algebra
                            ),
                            b(str("remove-private"),
                                c(
                                    b(str("all"),
                                        sc(
                                            b(str("replace"),
                                                sc(
                                                    str("nearest")
                                                )
                                            ).as(:oneline)
                                        )
                                    ).as(:oneline),
                                    str("no-peer-loop-check")
                                )
                            ),
                            b(str("cluster"),
                              areaid
                            ),
                            str("no-client-reflect"),
                            a(str("peer-as"), arg),
                            b(str("local-as"),
                                sc(
                                    arg,
                                    a(str("loops"), arg),
                                    str("private"),
                                    str("alias"),
                                    str("no-prepend-global-as")
                                )
                            ).as(:oneline),
                            a(str("ipsec-sa"), arg),
                            b(str("graceful-shutdown"),
                                c(
                                    b(str("receiver"),
                                        c(
                                            str("disable"),
                                            a(str("local-preference"), arg)
                                        )
                                    ),
                                    b(str("sender"),
                                        c(
                                            a(str("local-preference"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("shutdown"),
                                c(
                                    a(str("notify-message"), arg)
                                )
                            ),
                            str("unconfigured-peer-graceful-restart"),
                            b(str("graceful-restart"),
                                c(
                                      (str("disable")),
                                    a(str("restart-time"), arg),
                                    a(str("stale-routes-time"), arg),
                                    b(str("long-lived"),
                                        c(
                                            b(str("receiver"),
                                                c(
                                                      (str("disable"))
                                                )
                                            ),
                                            b(str("advertise-to-non-llgr-neighbor"),
                                                c(
                                                    str("omit-no-export")
                                                )
                                            )
                                        )
                                    ),
                                    str("disable-notification-extensions"),
                                    b(str("forwarding-state-bit"),
                                      (str("as-rr-client") | str("from-fib"))
                                    ),
                                    str("dont-help-shared-fate-bfd-down")
                                )
                            ),
                            str("include-mp-next-hop"),
                            str("disable-4byte-as"),
                            b(str("idle-after-switch-over"),
                                sc(
                                    c(
                                      str("forever"),
                                        arg
                                    )
                                )
                            ).as(:oneline),
                            b(str("outbound-route-filter"),
                                c(
                                    str("bgp-orf-cisco-mode"),
                                    b(str("extended-community"),
                                        c(
                                            str("accept"),
                                            str("no-accept"),
                                            str("vrf-filter")
                                        )
                                    ),
                                    b(str("prefix-based"),
                                        c(
                                            b(str("accept"),
                                                c(
                                                    str("inet6"),
                                                    str("inet")
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("message-batching"),
                                c(
                                      (str("enable") | str("disable")),
                                    a(str("interval"), arg)
                                )
                            ),
                            b(str("multipath"),
                                c(
                                    str("disable"),
                                    str("multiple-as"),
                                    str("allow-protection")
                                )
                            ),
                            a(str("tcp-mss"), arg),
                            str("tcp-aggressive-transmission"),
                            b(str("bmp"),
                                c(
                                    b(str("monitor"),
                                      (str("enable") | str("disable"))
                                    ),
                                    b(str("route-monitoring"),
                                        c(
                                            str("none"),
                                            b(str("pre-policy"),
                                                sc(
                                                    str("exclude-non-feasible")
                                                )
                                            ).as(:oneline),
                                            b(str("post-policy"),
                                                sc(
                                                    str("exclude-non-eligible")
                                                )
                                            ).as(:oneline),
                                            b(str("rib-out"),
                                                sc(
                                                    str("pre-policy"),
                                                    str("post-policy")
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("advertise-bgp-static"),
                                c(
                                    b(str("policy"),
                                      policy_algebra
                                    )
                                )
                            ),
                            str("add-path-display-ipv4-address"),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("authentication"),
                                        c(
                                            a(str("key-chain"), arg),
                                            b(str("algorithm"),
                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                            ),
                                            str("loose-check")
                                        )
                                    ),
                                    b(str("session-mode"),
                                      (str("automatic") | str("single-hop") | str("multihop"))
                                    ),
                                    a(str("holddown-interval"), arg)
                                )
                            ),
                            str("as-override"),
                            b(str("egress-te-node-segment"),
                                c(
                                    b(str("label"),
                                        c(
                                              arg
                                        )
                                    ),
                                    b(str("egress-te-set"),
                                        ca(
                                            a(str("weight"), arg)
                                        )
                                    ),
                                    b(str("egress-te-backup-segment"),
                                        c(
                                            b(str("label"),
                                                c(
                                                      arg
                                                )
                                            )
                                        )
                                    ),
                                    b(str("egress-te-backup-ip-forward"),
                                        c(
                                            arg
                                        )
                                    )
                                )
                            ),
                            b(a(str("egress-te-adj-segment"), arg),
                                c(
                                    b(str("label"),
                                        c(
                                              arg
                                        )
                                    ),
                                    b(str("next-hop"),
                                        c(
                                              ipaddr
                                        )
                                    ),
                                    b(str("egress-te-set"),
                                        ca(
                                            a(str("weight"), arg)
                                        )
                                    ),
                                    b(str("egress-te-backup-segment"),
                                        c(
                                            b(str("label"),
                                                c(
                                                      arg
                                                )
                                            )
                                        )
                                    ),
                                    b(str("egress-te-backup-ip-forward"),
                                        c(
                                            arg
                                        )
                                    )
                                )
                            ),
                            str("vpn-apply-export"),
                            b(str("egress-te"),
                                c(
                                    b(str("install-address"),
                                      ipaddr
                                    ),
                                    b(str("rib"),
                                        c(
                                            str("inet.0"),
                                            str("inet6.0")
                                        )
                                    ),
                                    str("no-install"),
                                    b(str("import"),
                                      policy_algebra
                                    ),
                                    a(str("backup-path"), arg)
                                )
                            )
                        )
                    ),
                    str("vpn-apply-export"),
                    b(str("egress-te"),
                        c(
                            b(str("install-address"),
                              ipaddr
                            ),
                            b(str("rib"),
                                c(
                                    str("inet.0"),
                                    str("inet6.0")
                                )
                            ),
                            str("no-install"),
                            b(str("import"),
                              policy_algebra
                            ),
                            a(str("backup-path"), arg)
                        )
                    )
                )
            ),
            b(str("traffic-statistics-labeled-path"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("interval"), arg)
                )
            ),
              (str("disable")),
            str("precision-timers"),
            str("no-precision-timers"),
            b(str("snmp-options"),
                c(
                    str("backward-traps-only-from-established"),
                    str("emit-inet-address-length-in-oid")
                )
            ),
            str("route-age-bgp-view"),
            str("prioritize-route-queueing"),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("damping") | str("packets") | str("open") | str("update") | str("keepalive") | str("refresh") | str("nsr-synchronization") | str("bfd") | str("4byte-as") | str("add-path") | str("graceful-restart") | str("egress-te") | str("thread-io") | str("sharding") | str("thread-update-io") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable"),
                            b(str("filter"),
                              bgp_filter_obj
                            )
                        )
                    ).as(:oneline)
                )
            ),
            a(str("description"), quote | arg),
            b(str("metric-out"),
                sc(
                    ca(
                      b(str("minimum-igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("igp"),
                          sc(
                              arg,
                              str("delay-med-update")
                          )
                      ).as(:oneline),
                      b(str("effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline)
                    )
                )
            ).as(:oneline),
            b(str("multihop"),
                c(
                    a(str("ttl"), arg),
                    str("no-nexthop-change")
                )
            ),
            str("route-server-client"),
            str("accept-remote-nexthop"),
            a(str("preference"), arg),
            a(str("local-preference"), arg),
            b(str("local-address"),
              ipaddr
            ),
            b(str("local-interface"),
              interface_name
            ),
            a(str("forwarding-context"), arg),
            a(str("hold-time"), arg),
            a(str("minimum-hold-time"), arg),
            str("passive"),
            str("advertise-inactive"),
            str("advertise-peer-as"),
            str("no-advertise-peer-as"),
            b(str("advertise-external"),
                sc(
                    str("conditional")
                )
            ).as(:oneline),
            b(str("keep"),
              (str("all") | str("none"))
            ),
            str("rfc6514-compliant-safi129"),
            str("no-aggregator-id"),
            str("mtu-discovery"),
            str("enforce-first-as"),
            a(str("out-delay"), arg),
            b(str("ttl"),
              (str("1") | str("255"))
            ),
            str("log-updown"),
            str("damping"),
            b(str("import"),
              policy_algebra
            ),
            b(str("nlri"),
              (str("unicast") | str("multicast") | str("any"))
            ),
            b(str("bgp-error-tolerance"),
                c(
                    a(str("malformed-update-log-interval"), arg),
                    c(
                      a(str("malformed-route-limit"), arg),
                      str("no-malformed-route-limit")
                    )
                )
            ),
            a(str("authentication-key"), arg),
            b(str("authentication-algorithm"),
              (str("md5") | str("hmac-sha-1-96") | str("aes-128-cmac-96"))
            ),
            a(str("authentication-key-chain"), arg),
            b(str("export"),
              policy_algebra
            ),
            b(str("remove-private"),
                c(
                    b(str("all"),
                        sc(
                            b(str("replace"),
                                sc(
                                    str("nearest")
                                )
                            ).as(:oneline)
                        )
                    ).as(:oneline),
                    str("no-peer-loop-check")
                )
            ),
            b(str("cluster"),
              areaid
            ),
            str("no-client-reflect"),
            a(str("peer-as"), arg),
            b(str("local-as"),
                sc(
                    arg,
                    a(str("loops"), arg),
                    str("private"),
                    str("alias"),
                    str("no-prepend-global-as")
                )
            ).as(:oneline),
            a(str("ipsec-sa"), arg),
            b(str("graceful-shutdown"),
                c(
                    b(str("receiver"),
                        c(
                            str("disable"),
                            a(str("local-preference"), arg)
                        )
                    ),
                    b(str("sender"),
                        c(
                            a(str("local-preference"), arg)
                        )
                    )
                )
            ),
            b(str("shutdown"),
                c(
                    a(str("notify-message"), arg)
                )
            ),
            str("unconfigured-peer-graceful-restart"),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-time"), arg),
                    a(str("stale-routes-time"), arg),
                    b(str("long-lived"),
                        c(
                            b(str("receiver"),
                                c(
                                      (str("disable"))
                                )
                            ),
                            b(str("advertise-to-non-llgr-neighbor"),
                                c(
                                    str("omit-no-export")
                                )
                            )
                        )
                    ),
                    str("disable-notification-extensions"),
                    b(str("forwarding-state-bit"),
                      (str("as-rr-client") | str("from-fib"))
                    ),
                    str("dont-help-shared-fate-bfd-down")
                )
            ),
            str("include-mp-next-hop"),
            str("disable-4byte-as"),
            b(str("idle-after-switch-over"),
                sc(
                    c(
                      str("forever"),
                        arg
                    )
                )
            ).as(:oneline),
            b(str("outbound-route-filter"),
                c(
                    str("bgp-orf-cisco-mode"),
                    b(str("extended-community"),
                        c(
                            str("accept"),
                            str("no-accept"),
                            str("vrf-filter")
                        )
                    ),
                    b(str("prefix-based"),
                        c(
                            b(str("accept"),
                                c(
                                    str("inet6"),
                                    str("inet")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("message-batching"),
                c(
                      (str("enable") | str("disable")),
                    a(str("interval"), arg)
                )
            ),
            b(str("multipath"),
                c(
                    str("disable"),
                    str("multiple-as"),
                    str("allow-protection")
                )
            ),
            a(str("tcp-mss"), arg),
            str("tcp-aggressive-transmission"),
            b(str("bmp"),
                c(
                    b(str("monitor"),
                      (str("enable") | str("disable"))
                    ),
                    b(str("route-monitoring"),
                        c(
                            str("none"),
                            b(str("pre-policy"),
                                sc(
                                    str("exclude-non-feasible")
                                )
                            ).as(:oneline),
                            b(str("post-policy"),
                                sc(
                                    str("exclude-non-eligible")
                                )
                            ).as(:oneline),
                            b(str("rib-out"),
                                sc(
                                    str("pre-policy"),
                                    str("post-policy")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("advertise-bgp-static"),
                c(
                    b(str("policy"),
                      policy_algebra
                    )
                )
            ),
            str("add-path-display-ipv4-address"),
            b(str("bfd-liveness-detection"),
                c(
                    b(str("version"),
                      (str("0") | str("1") | str("automatic"))
                    ),
                    a(str("minimum-interval"), arg),
                    a(str("minimum-transmit-interval"), arg),
                    a(str("minimum-receive-interval"), arg),
                    a(str("multiplier"), arg),
                    c(
                      str("no-adaptation")
                    ),
                    b(str("transmit-interval"),
                        c(
                            a(str("minimum-interval"), arg),
                            a(str("threshold"), arg)
                        )
                    ),
                    b(str("detection-time"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ),
                    b(str("authentication"),
                        c(
                            a(str("key-chain"), arg),
                            b(str("algorithm"),
                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                            ),
                            str("loose-check")
                        )
                    ),
                    b(str("session-mode"),
                      (str("automatic") | str("single-hop") | str("multihop"))
                    ),
                    a(str("holddown-interval"), arg)
                )
            ),
            b(str("output-queue-priority"),
                c(
                    b(str("expedited"),
                        sc(
                            a(str("update-tokens"), arg)
                        )
                    ).as(:oneline),
                    b(a(str("priority"), arg),
                        sc(
                            a(str("update-tokens"), arg)
                        )
                    ).as(:oneline),
                    b(str("defaults"),
                        c(
                            b(str("low"),
                              bgp_output_queue_priority_class
                            ),
                            b(str("medium"),
                              bgp_output_queue_priority_class
                            ),
                            b(str("high"),
                              bgp_output_queue_priority_class
                            )
                        )
                    )
                )
            ),
            b(str("multipath-build-priority"),
                c(
                    c(
                      str("low"),
                      str("medium")
                    )
                )
            ),
            str("send-addpath-optimization"),
            a(str("drop-path-attributes"), arg),
            a(str("minimum-hold-time"), arg)
        )
    end

    rule(:bgp_af_gr) do
        c(
            b(str("long-lived"),
                c(
                    b(str("restarter"),
                        c(
                              (str("disable")),
                            a(str("stale-time"), arg)
                        )
                    )
                )
            ),
            b(str("forwarding-state-bit"),
              (str("set") | str("from-fib"))
            )
        )
    end

    rule(:bgp_afi_default) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            )
        )
    end

    rule(:apath_options) do
        c(
            str("receive"),
            b(str("send"),
                c(
                    b(str("path-selection-mode"),
                        c(
                            c(
                              str("all-paths"),
                              str("equal-cost-paths")
                            )
                        )
                    ),
                    b(str("prefix-policy"),
                      policy_algebra
                    ),
                    a(str("path-count"), arg),
                    a(str("include-backup-path"), arg),
                    str("multipath")
                )
            )
        )
    end

    rule(:bgp_afi_flow) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("no-validate"),
              policy_algebra
            ),
            str("strip-nexthop"),
            str("allow-policy-add-nexthop")
        )
    end

    rule(:bgp_afi_flow_with_redirect_ip_action) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("no-validate"),
              policy_algebra
            ),
            str("strip-nexthop"),
            b(str("legacy-redirect-ip-action"),
                c(
                    str("receive"),
                    str("send")
                )
            ),
            str("secondary-independent-resolution")
        )
    end

    rule(:bgp_afi_inet6_labeled) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("aggregate-label"),
                c(
                    a(str("community"), arg)
                )
            ),
            str("per-group-label"),
            b(str("traffic-statistics"),
              bgpaf_traffic_statistics
            ),
            b(str("rib"),
                c(
                    str("inet6.3")
                )
            ),
            b(str("explicit-null"),
                sc(
                    str("connected-only")
                )
            ).as(:oneline),
            str("protection").as(:oneline)
        )
    end

    rule(:bgp_afi_l2vpn) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("egress-protection"),
                c(
                    b(str("context-identifier"),
                        c(
                              ipv4addr
                        )
                    ),
                    b(str("keep-import"),
                      policy_algebra
                    )
                )
            )
        )
    end

    rule(:bgp_afi_l3vpn) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("aggregate-label"),
                c(
                    a(str("community"), arg)
                )
            ),
            b(str("egress-protection"),
                c(
                    b(str("context-identifier"),
                        c(
                              ipv4addr
                        )
                    ),
                    b(str("keep-import"),
                      policy_algebra
                    )
                )
            ),
            str("accept-local-nexthop")
        )
    end

    rule(:bgp_afi_labeled) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("aggregate-label"),
                c(
                    a(str("community"), arg)
                )
            ),
            str("per-prefix-label"),
            str("per-group-label"),
            b(str("traffic-statistics"),
              bgpaf_traffic_statistics
            ),
            b(str("rib"),
                c(
                    str("inet.3")
                )
            ),
            b(str("explicit-null"),
                sc(
                    str("connected-only")
                )
            ).as(:oneline),
            str("protection"),
            b(str("egress-protection"),
                c(
                    b(str("context-identifier"),
                        c(
                              ipv4addr
                        )
                    ),
                    b(str("keep-import"),
                      policy_algebra
                    )
                )
            ),
            str("resolve-vpn"),
            b(str("entropy-label"),
                c(
                    b(str("import"),
                      policy_algebra
                    ),
                    str("no-next-hop-validation")
                )
            )
        )
    end

    rule(:bgp_afi_srte) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            str("damping"),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("no-install"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            )
        )
    end

    rule(:bgp_afi_topo) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            str("protection").as(:oneline),
            b(a(str("topology"), arg),
                c(
                    a(str("community"), arg)
                )
            )
        )
    end

    rule(:bgp_afi_vpn) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("aggregate-label"),
                c(
                    a(str("community"), arg)
                )
            )
        )
    end

    rule(:bgp_afi_vpn_protection) do
        c(
            b(str("prefix-limit"),
              bgpaf_prefix_limit
            ),
            b(str("accepted-prefix-limit"),
              bgpaf_accepted_prefix_limit
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("add-path"),
              apath_options
            ),
            b(str("aigp"),
              bgpaf_aigp_options
            ),
            str("damping"),
            b(str("local-ipv4-address"),
              ipv4addr
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("delay-route-advertisements"),
                c(
                    str("always-wait-for-krt-drain"),
                    b(str("minimum-delay"),
                        c(
                            a(str("routing-uptime"), arg),
                            a(str("inbound-convergence"), arg)
                        )
                    ),
                    b(str("maximum-delay"),
                        c(
                            a(str("route-age"), arg),
                            a(str("routing-uptime"), arg)
                        )
                    )
                )
            ),
            b(str("nexthop-resolution"),
                c(
                    str("no-resolution"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("defer-initial-multipath-build"),
                c(
                    a(str("maximum-delay"), arg)
                )
            ),
            b(str("graceful-restart"),
              bgp_af_gr
            ),
            str("extended-nexthop"),
            str("extended-nexthop-color"),
            str("no-install"),
            str("route-age-bgp-view"),
            b(str("output-queue-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("route-refresh-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("withdraw-priority"),
              bgp_output_queue_priority_class
            ),
            b(str("aggregate-label"),
                c(
                    a(str("community"), arg)
                )
            ),
            b(str("egress-protection"),
                c(
                    b(str("context-identifier"),
                        c(
                              ipv4addr
                        )
                    ),
                    b(str("keep-import"),
                      policy_algebra
                    )
                )
            )
        )
    end

    rule(:bgp_output_queue_priority_class) do
        c(
            c(
              a(str("priority"), arg),
              str("expedited")
            )
        ).as(:oneline)
    end

    rule(:bgp_filter_obj) do
        c(
            b(str("match-on"),
              (str("prefix"))
            ),
            b(str("policy"),
              policy_algebra
            )
        ).as(:oneline)
    end

    rule(:bgpaf_accepted_prefix_limit) do
        c(
            a(str("maximum"), arg),
            b(a(str("teardown"), arg),
                ca(
                    b(str("idle-timeout"),
                        sc(
                            c(
                              str("forever"),
                                arg
                            )
                        )
                    ).as(:oneline)
                )
            ),
            str("teardown")
        )
    end

    rule(:bgpaf_aigp_options) do
        c(
            str("disable")
        )
    end

    rule(:bgpaf_loops) do
        c(
              arg
        ).as(:oneline)
    end

    rule(:bgpaf_prefix_limit) do
        c(
            a(str("maximum"), arg),
            b(a(str("teardown"), arg),
                ca(
                    b(str("idle-timeout"),
                        sc(
                            c(
                              str("forever"),
                                arg
                            )
                        )
                    ).as(:oneline)
                )
            ),
            str("teardown")
        )
    end

    rule(:bgpaf_traffic_statistics) do
        c(
            str("labeled-path"),
            b(str("file"),
                sc(
                      arg,
                    str("replace"),
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("no-stamp"),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            a(str("interval"), arg)
        )
    end

    rule(:juniper_protocols_bridge) do
        c(
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    b(str("level"),
                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                    ),
                    a(str("flag"), enum(str("configuration") | str("routing-socket") | str("interface-device") | str("interface-logical") | str("interface-family") | str("bridging-domain") | str("routing-instance") | str("bridge-interface") | str("learning-domain") | str("ipc") | str("mac-learning") | str("initialization") | str("flood-next-hop") | str("irb") | str("vpls-ping") | str("vpls-loop-prev") | str("logical-system") | str("bmac-next-hop") | str("bridge-bmac-next-hop") | str("isid") | str("mc-ae") | str("kack") | str("storm-control") | str("redundant-trunk-group") | str("unknown-unicast-forwarding") | str("vxlan") | str("all"))).as(:oneline),
                    str("in-memory-debug")
                )
            ),
            b(str("global-mac-move"),
                c(
                    a(str("notification-time"), arg),
                    a(str("threshold-time"), arg),
                    a(str("reopen-time"), arg),
                    a(str("threshold-count"), arg),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    str("log"),
                    str("disable-action"),
                    a(str("cooloff-time"), arg),
                    a(str("statistical-approach-wait-time"), arg),
                    a(str("interface-recovery-time"), arg),
                    a(str("exclusive-mac"), arg)
                )
            ),
            a(str("global-mac-table-aging-time"), arg),
            a(str("global-mac-ip-table-aging-time"), arg),
            b(str("global-mode"),
              (str("transparent-bridge") | str("switching"))
            ),
            a(str("global-le-aging-time"), arg),
            a(str("global-le-bridge-domain-aging-time"), arg),
            str("mclag-arpreq-sync"),
            a(str("global-mac-pinning-discard-notification-interval"), arg),
            b(str("global-mac-limit"),
                ca(
                    b(str("packet-action"),
                      (str("drop"))
                    )
                )
            ),
            b(str("global-mac-ip-limit"),
                c(
                      arg
                )
            ),
            str("global-mac-statistics"),
            str("global-static-mac-move-drop-log"),
            str("decapsulate-accept-inner-vlan"),
            a(str("destination-udp-port"), arg),
            a(str("source-udp-port"), arg),
            b(str("disable-vxlan-multicast-transit"),
                c(
                    a(str("vxlan-multicast-group"), str("all") | str("multicast-group-ip"))
                )
            ),
            str("global-no-mac-learning"),
            str("global-no-hw-mac-learning"),
            str("global-no-control-mac-aging"),
            str("mclag-arp-nd-sync"),
            str("no-mclag-ifa-sync")
        )
    end

    rule(:juniper_protocols_dot1x) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("dot1x-debug") | str("parse") | str("esw-if") | str("eapol") | str("config-internal") | str("normal") | str("general") | str("state") | str("task") | str("timer") | str("vlan") | str("all") | str("dot1x-ipc") | str("dot1x-event") | str("iccp")),
                        sc(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("authenticator"),
                c(
                    a(str("authentication-profile-name"), arg),
                    str("no-mac-table-binding"),
                    b(str("radius-options"),
                        c(
                            str("add-interface-text-description"),
                            c(
                              str("use-vlan-name"),
                              str("use-vlan-id")
                            )
                        )
                    ),
                    b(a(str("static"), arg),
                        c(
                            a(str("vlan-assignment"), arg),
                            a(str("bridge-domain-assignment"), arg),
                            b(str("interface"),
                              interface_name
                            )
                        )
                    ),
                    a(str("interface"), str("all") | arg,
                        c(
                            str("ignore-port-bounce"),
                            b(str("authentication-order"),
                              (str("dot1x") | str("mac-radius") | str("captive-portal"))
                            ),
                            str("disable"),
                            b(str("supplicant"),
                              (str("single") | str("single-secure") | str("multiple"))
                            ),
                            a(str("retries"), arg),
                            a(str("quiet-period"), arg),
                            a(str("transmit-period"), arg),
                            b(str("multi-domain"),
                                c(
                                    b(str("packet-action"),
                                      (str("drop-and-log") | str("shutdown"))
                                    ),
                                    a(str("max-data-session"), arg),
                                    a(str("recovery-timeout"), arg)
                                )
                            ),
                            b(str("mac-radius"),
                                c(
                                    str("restrict"),
                                    str("flap-on-disconnect"),
                                    b(str("authentication-protocol"),
                                        c(
                                            c(
                                              str("eap-md5"),
                                              str("pap"),
                                              b(str("eap-peap"),
                                                  c(
                                                      str("resume")
                                                  )
                                              )
                                            )
                                        )
                                    )
                                )
                            ),
                            c(
                              str("no-reauthentication"),
                              a(str("reauthentication"), arg)
                            ),
                            a(str("supplicant-timeout"), arg),
                            a(str("server-timeout"), arg),
                            a(str("maximum-requests"), arg),
                            a(str("request-retry-count"), arg),
                            a(str("guest-vlan"), arg),
                            a(str("guest-bridge-domain"), arg),
                            b(str("server-reject-vlan"),
                                sc(
                                    arg,
                                    a(str("block-interval"), arg),
                                    str("eapol-block")
                                )
                            ).as(:oneline),
                            b(str("server-reject-bridge-domain"),
                                sc(
                                    arg,
                                    a(str("block-interval"), arg),
                                    str("eapol-block")
                                )
                            ).as(:oneline),
                            b(str("eapol-block"),
                                c(
                                    b(str("server-fail"),
                                        c(
                                              arg
                                        )
                                    ),
                                    str("mac-radius"),
                                    str("captive-portal")
                                )
                            ),
                            str("lldp-med-bypass"),
                            b(str("server-fail"),
                                sc(
                                    c(
                                      str("deny"),
                                      str("permit"),
                                      a(str("vlan-name"), arg),
                                      a(str("bridge-domain"), arg),
                                      str("use-cache")
                                    )
                                )
                            ).as(:oneline),
                            b(str("server-fail-voip"),
                                sc(
                                    c(
                                      str("deny"),
                                      str("permit"),
                                      a(str("vlan-name"), arg),
                                      str("use-cache")
                                    )
                                )
                            ).as(:oneline),
                            a(str("redirect-url"), arg),
                            str("no-tagged-mac-authentication"),
                            str("retain-mac-aged-session")
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_esis) do
        c(
              (str("disable")),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("error") | str("esh") | str("ish") | str("graceful-restart") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("preference"), arg),
            b(str("graceful-restart"),
                sc(
                      (str("disable")),
                    a(str("restart-duration"), arg)
                )
            ).as(:oneline),
            b(a(str("interface"), arg),
                c(
                    a(str("hold-time"), arg),
                    a(str("end-system-configuration-timer"), arg),
                      (str("disable"))
                )
            )
        )
    end

    rule(:juniper_protocols_isis) do
        c(
            b(str("backup-spf-options"),
                c(
                    str("remote-backup-calculation"),
                    b(str("use-post-convergence-lfa"),
                        c(
                            a(str("maximum-labels"), arg),
                            a(str("maximum-backup-paths"), arg)
                        )
                    ),
                    str("use-source-packet-routing"),
                    str("per-prefix-calculation"),
                    str("node-link-degradation")
                )
            ),
            b(str("traffic-engineering"),
                c(
                      (str("disable")),
                    str("igp-topology"),
                    str("credibility-protocol-preference"),
                    str("ipv4-multicast-rpf-routes"),
                    str("ignore-lsp-metrics"),
                    b(str("tunnel-source-protocol"),
                        c(
                            b(str("rsvp"),
                                c(
                                    a(str("preference"), arg)
                                )
                            ),
                            b(str("spring-te"),
                                c(
                                    a(str("preference"), arg)
                                )
                            )
                        )
                    ),
                    a(str("family"), enum(str("inet6") | str("inet") | str("inet-mpls") | str("inet6-mpls")),
                        c(
                            b(str("shortcuts"),
                                c(
                                    str("multicast-rpf-routes")
                                )
                            )
                        )
                    ),
                    b(str("shortcuts"),
                        c(
                            str("ignore-lsp-metrics")
                        )
                    ),
                    b(str("multipath"),
                        c(
                            str("lsp-equal-cost")
                        )
                    ),
                    b(str("advertisement"),
                        c(
                            str("always")
                        )
                    )
                )
            ),
            b(str("source-packet-routing"),
                c(
                    b(str("adjacency-segment"),
                        c(
                            a(str("hold-time"), arg)
                        )
                    ),
                    b(str("sensor-based-stats"),
                        c(
                            b(str("per-interface-per-member-link"),
                                sc(
                                    str("ingress"),
                                    str("egress")
                                )
                            ).as(:oneline),
                            b(str("per-sid"),
                                sc(
                                    str("ingress"),
                                    str("egress")
                                )
                            ).as(:oneline)
                        )
                    ),
                    str("udp-tunneling"),
                    b(str("srgb"),
                        sc(
                            a(str("start-label"), arg),
                            a(str("index-range"), arg)
                        )
                    ).as(:oneline),
                    b(str("node-segment"),
                        c(
                            a(str("ipv4-index"), arg),
                            a(str("ipv6-index"), arg),
                            a(str("index-range"), arg)
                        )
                    ),
                    b(str("traffic-statistics"),
                        c(
                            b(str("statistics-granularity"),
                                c(
                                    str("per-interface")
                                )
                            ),
                            a(str("auto-bandwidth"), arg)
                        )
                    ),
                    str("explicit-null"),
                    a(str("mapping-server"), arg),
                    str("ldp-stitching")
                )
            ),
            b(a(str("level"), arg),
                c(
                      (str("disable")),
                    b(str("authentication-key"),
                      unreadable
                    ),
                    b(str("authentication-type"),
                      (str("md5") | str("simple"))
                    ),
                    b(str("purge-originator"),
                      (str("self") | str("empty"))
                    ),
                    str("no-hello-authentication"),
                    str("no-csnp-authentication"),
                    str("no-psnp-authentication"),
                    a(str("authentication-key-chain"), arg),
                    str("wide-metrics-only"),
                    a(str("preference"), arg),
                    a(str("external-preference"), arg),
                    a(str("prefix-export-limit"), arg),
                    a(str("labeled-preference"), arg),
                    b(str("source-packet-routing"),
                        c(
                              (str("disable"))
                        )
                    )
                )
            ),
            b(a(str("interface"), arg),
                c(
                      (str("disable")),
                    b(str("authentication-key"),
                      unreadable
                    ),
                    b(str("authentication-type"),
                      (str("md5") | str("simple"))
                    ),
                    a(str("flood-group"), arg),
                    b(str("hello-authentication-key"),
                      unreadable
                    ),
                    b(str("hello-authentication-type"),
                      (str("md5") | str("simple"))
                    ),
                    b(str("hello-padding-type"),
                      (str("strict") | str("adaptive") | str("loose") | str("disable"))
                    ),
                    a(str("interface-group-holddown-delay"), arg),
                    str("layer2-map"),
                    str("no-layer2-map"),
                    a(str("max-hello-size"), arg),
                    a(str("lsp-interval"), arg),
                    b(str("csnp-interval"),
                        sc(
                            ca(
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    b(str("strict-dual-isis"),
                        c(
                            a(str("holdown"), arg)
                        )
                    ),
                    b(str("mesh-group"),
                        sc(
                            ca(
                              str("blocked")
                            )
                        )
                    ).as(:oneline),
                    str("point-to-point"),
                    c(
                      str("link-protection"),
                      str("node-link-protection")
                    ),
                    str("no-eligible-backup"),
                    b(str("passive"),
                        c(
                            b(str("remote-node-iso"),
                              sysid
                            ),
                            b(str("remote-node-id"),
                              ipv4addr
                            )
                        )
                    ),
                    str("no-eligible-remote-backup"),
                    str("checksum"),
                    str("no-unicast-topology"),
                    str("no-ipv4-multicast"),
                    str("no-ipv6-unicast"),
                    str("no-ipv6-multicast"),
                    str("no-adjacency-down-notification"),
                    b(str("bfd-liveness-detection"),
                        c(
                            b(str("version"),
                              (str("0") | str("1") | str("automatic"))
                            ),
                            a(str("minimum-interval"), arg),
                            a(str("minimum-transmit-interval"), arg),
                            a(str("minimum-receive-interval"), arg),
                            a(str("multiplier"), arg),
                            c(
                              str("no-adaptation")
                            ),
                            b(str("transmit-interval"),
                                c(
                                    a(str("minimum-interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("detection-time"),
                                c(
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("authentication"),
                                c(
                                    a(str("key-chain"), arg),
                                    b(str("algorithm"),
                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                    ),
                                    str("loose-check")
                                )
                            )
                        )
                    ),
                    a(str("family"), enum(str("inet6") | str("inet")),
                        c(
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("authentication"),
                                        c(
                                            a(str("key-chain"), arg),
                                            b(str("algorithm"),
                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                            ),
                                            str("loose-check")
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("level"), arg),
                        c(
                              (str("disable")),
                            a(str("metric"), arg),
                            a(str("ipv4-multicast-metric"), arg),
                            a(str("ipv6-unicast-metric"), arg),
                            a(str("ipv6-multicast-metric"), arg),
                            a(str("topology"), enum(str("default") | str("ipv4-multicast") | str("ipv6-unicast") | str("ipv6-multicast")),
                                c(
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("authentication-key"),
                              unreadable
                            ),
                            b(str("authentication-type"),
                              (str("md5") | str("simple"))
                            ),
                            b(str("hello-authentication-key"),
                              unreadable
                            ),
                            b(str("hello-authentication-type"),
                              (str("md5") | str("simple"))
                            ),
                            a(str("hello-authentication-key-chain"), arg),
                            a(str("hello-interval"), arg),
                            a(str("hold-time"), arg),
                            a(str("priority"), arg),
                            b(str("passive"),
                                c(
                                    b(str("remote-node-iso"),
                                      sysid
                                    ),
                                    b(str("remote-node-id"),
                                      ipv4addr
                                    )
                                )
                            ),
                            b(str("post-convergence-lfa"),
                                c(
                                    b(str("node-protection"),
                                        c(
                                            a(str("cost"), arg)
                                        )
                                    ),
                                    str("fate-sharing-protection")
                                )
                            ),
                            str("no-advertise-adjacency-segment"),
                            a(str("te-metric"), arg),
                            b(str("ipv4-adjacency-segment"),
                                c(
                                    b(str("protected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("unprotected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("ipv6-adjacency-segment"),
                                c(
                                    b(str("protected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("unprotected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(a(str("lan-neighbor"), arg),
                                c(
                                    b(str("ipv4-adjacency-segment"),
                                        c(
                                            b(str("protected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("unprotected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("ipv6-adjacency-segment"),
                                        c(
                                            b(str("protected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("unprotected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("link-degradation-threshold"),
                        sc(
                            a(str("link-down"), arg),
                            a(str("link-up"), arg)
                        )
                    ).as(:oneline),
                    b(str("auto-bandwidth"),
                        c(
                            a(str("template-name"), arg),
                              (str("disable"))
                        )
                    ),
                    str("no-advertise-adjacency-segment"),
                    b(str("ldp-synchronization"),
                      ldp_sync_obj
                    )
                )
            ),
            b(a(str("interface-group"), arg),
                c(
                    b(a(str("interface"), arg),
                        c(
                            a(str("weight"), arg)
                        )
                    ),
                    b(a(str("level"), arg),
                        c(
                            a(str("topology"), enum(str("default") | str("ipv4-multicast") | str("ipv6-unicast") | str("ipv6-multicast")),
                                c(
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("ipv4-adjacency-segment"),
                                c(
                                    b(str("protected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("unprotected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("ipv6-adjacency-segment"),
                                c(
                                    b(str("protected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("unprotected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("link-group-protection"),
                        c(
                            a(str("minimum-bandwidth"), arg),
                            a(str("revert-bandwidth"), arg)
                        )
                    )
                )
            ),
            b(a(str("label-switched-path"), arg),
                c(
                    b(a(str("level"), arg),
                        c(
                              (str("disable")),
                            a(str("metric"), arg)
                        )
                    )
                )
            ),
            b(a(str("context-identifier"), arg),
                c(
                    b(a(str("level"), arg),
                        c(
                              (str("disable"))
                        )
                    )
                )
            ),
              (str("disable")),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("error") | str("spf") | str("packets") | str("hello") | str("lsp") | str("psn") | str("csn") | str("layer2-map") | str("lsp-generation") | str("graceful-restart") | str("ldp-synchronization") | str("nsr-synchronization") | str("spring") | str("traffic-statistics") | str("prefix-sid") | str("adj-sid") | str("post-convergence-lfa") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("export"),
              policy_algebra
            ),
            b(str("import"),
              policy_algebra
            ),
            a(str("reference-bandwidth"), arg),
            str("layer2-map"),
            str("no-layer2-map"),
            str("job-stats"),
            a(str("lsp-lifetime"), arg),
            a(str("max-lsp-size"), arg),
            a(str("max-hello-size"), arg),
            a(str("max-snp-size"), arg),
            a(str("spf-delay"), arg),
            b(str("authentication-key"),
              unreadable
            ),
            b(str("authentication-type"),
              (str("md5") | str("simple"))
            ),
            str("loose-authentication-check"),
            a(str("max-areas"), arg),
            str("no-authentication-check"),
            str("no-ipv4-routing"),
            str("no-ipv6-routing"),
            str("clns-routing"),
            str("clns-updown-compatibility"),
            str("no-adjacency-holddown"),
            str("multicast-topology"),
            str("ignore-attached-bit"),
            b(str("rib-group"),
              rib_group_type
            ),
            b(str("strict-dual-isis"),
                c(
                    a(str("holdown"), arg)
                )
            ),
            b(str("spf-options"),
                c(
                    a(str("delay"), arg),
                    a(str("holddown"), arg),
                    a(str("rapid-runs"), arg),
                    b(str("multipath"),
                        c(
                            b(str("weighted"),
                                c(
                                    str("one-hop")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("topologies"),
                c(
                    str("ipv4-multicast"),
                    str("ipv6-unicast"),
                    str("ipv6-multicast")
                )
            ),
            b(str("overload"),
                c(
                    a(str("timeout"), arg),
                    str("advertise-high-metrics"),
                    str("allow-route-leaking"),
                    str("internal-prefixes"),
                    str("external-prefixes")
                )
            ),
            b(str("graceful-restart"),
                sc(
                      (str("disable")),
                    str("helper-disable"),
                    a(str("restart-duration"), arg)
                )
            ).as(:oneline)
        )
    end

    rule(:juniper_protocols_l2control) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("parse") | str("regex-parse") | str("config-internal") | str("normal") | str("general") | str("state") | str("task") | str("timer") | str("ppmlite") | str("all")),
                        sc(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            str("nonstop-bridging"),
            b(str("options"),
                c(
                    b(str("nsb-extended-timers"),
                        c(
                              (str("disable"))
                        )
                    ),
                    b(str("nsb-optimized-config-read"),
                        c(
                              (str("disable"))
                        )
                    )
                )
            ),
            b(str("bpdu-block"),
                c(
                    a(str("interface"), str("all") | arg,
                        c(
                            str("disable"),
                            str("drop")
                        )
                    ),
                    a(str("disable-timeout"), arg)
                )
            ),
            b(str("mac-rewrite"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            str("enable-all-ifl"),
                            b(str("protocol"),
                                c(
                                    str("stp"),
                                    str("vtp"),
                                    str("cdp"),
                                    str("ieee8021x"),
                                    str("ieee8023ah"),
                                    str("elmi"),
                                    str("lacp"),
                                    str("lldp"),
                                    str("mmrp"),
                                    str("mvrp"),
                                    str("pvstp"),
                                    str("gvrp"),
                                    str("vstp"),
                                    str("udld")
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_ldp) do
        c(
            b(str("oam"),
                c(
                    b(a(str("fec"), arg),
                        c(
                            c(
                              b(str("bfd-liveness-detection"),
                                  c(
                                      b(str("version"),
                                        (str("0") | str("1") | str("automatic"))
                                      ),
                                      a(str("minimum-interval"), arg),
                                      a(str("minimum-transmit-interval"), arg),
                                      a(str("minimum-receive-interval"), arg),
                                      a(str("multiplier"), arg),
                                      c(
                                        str("no-adaptation")
                                      ),
                                      b(str("transmit-interval"),
                                          c(
                                              a(str("minimum-interval"), arg),
                                              a(str("threshold"), arg)
                                          )
                                      ),
                                      b(str("detection-time"),
                                          c(
                                              a(str("threshold"), arg)
                                          )
                                      ),
                                      str("ecmp"),
                                      b(str("failure-action"),
                                          sc(
                                              c(
                                                str("remove-route"),
                                                str("remove-nexthop")
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("holddown-interval"), arg),
                                      str("no-router-alert-option"),
                                      str("use-ip-ttl-1")
                                  )
                              ),
                              str("no-bfd-liveness-detection")
                            ),
                            b(str("periodic-traceroute"),
                                c(
                                    a(str("frequency"), arg),
                                    a(str("ttl"), arg),
                                    a(str("retries"), arg),
                                    a(str("wait"), arg),
                                    a(str("paths"), arg),
                                    b(str("source"),
                                      ipv4addr
                                    ),
                                    a(str("exp"), arg),
                                    a(str("fanout"), arg),
                                    str("disable")
                                )
                            )
                        )
                    ),
                    b(str("periodic-traceroute"),
                        c(
                            a(str("frequency"), arg),
                            a(str("ttl"), arg),
                            a(str("retries"), arg),
                            a(str("wait"), arg),
                            a(str("paths"), arg),
                            b(str("source"),
                              ipv4addr
                            ),
                            a(str("exp"), arg),
                            a(str("fanout"), arg)
                        )
                    ),
                    a(str("lsp-ping-interval"), arg),
                    b(str("ingress-policy"),
                      policy_algebra
                    ),
                    b(str("bfd-port-egress-policy"),
                      policy_algebra
                    ),
                    b(str("bfd-liveness-detection"),
                        c(
                            b(str("version"),
                              (str("0") | str("1") | str("automatic"))
                            ),
                            a(str("minimum-interval"), arg),
                            a(str("minimum-transmit-interval"), arg),
                            a(str("minimum-receive-interval"), arg),
                            a(str("multiplier"), arg),
                            c(
                              str("no-adaptation")
                            ),
                            b(str("transmit-interval"),
                                c(
                                    a(str("minimum-interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("detection-time"),
                                c(
                                    a(str("threshold"), arg)
                                )
                            ),
                            str("ecmp"),
                            b(str("failure-action"),
                                sc(
                                    c(
                                      str("remove-route"),
                                      str("remove-nexthop")
                                    )
                                )
                            ).as(:oneline),
                            a(str("holddown-interval"), arg),
                            str("no-router-alert-option"),
                            str("use-ip-ttl-1")
                        )
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("error") | str("event") | str("packet-dump") | str("packets") | str("periodic") | str("initialization") | str("notification") | str("address") | str("label") | str("binding") | str("path") | str("ppmd") | str("nsr-synchronization") | str("link-protection") | str("p2mp-nsr-synchronization") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable"),
                            b(str("filter"),
                              ldp_filter_obj
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("traffic-statistics"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("interval"), arg),
                    str("sensor-based-stats"),
                    str("no-penultimate-hop")
                )
            ),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    str("helper-disable"),
                    a(str("recovery-time"), arg),
                    a(str("maximum-neighbor-recovery-time"), arg),
                    a(str("reconnect-time"), arg),
                    a(str("maximum-neighbor-reconnect-time"), arg)
                )
            ),
            b(str("auto-targeted-session"),
                c(
                    a(str("teardown-delay"), arg),
                    a(str("maximum-sessions"), arg),
                    str("no-rlfa"),
                    str("no-dynamic-tunnels")
                )
            ),
            a(str("preference"), arg),
            str("no-forwarding"),
            a(str("rib-group"), arg),
            a(str("rib-group6"), arg),
            str("l2-smart-policy"),
            str("track-igp-metric"),
            str("strict-targeted-hellos"),
            b(str("longest-match"),
                c(
                      arg
                )
            ),
            b(str("color-import-policy"),
              policy_algebra
            ),
            b(str("import"),
              policy_algebra
            ),
            b(str("export"),
              policy_algebra
            ),
            b(str("egress-policy"),
              policy_algebra
            ),
            b(str("dod-request-policy"),
              policy_algebra
            ),
            b(str("next-hop"),
                c(
                    b(str("merged"),
                        c(
                            b(str("policy"),
                              policy_algebra
                            )
                        )
                    ),
                    b(str("no-rsvp-tunneling"),
                        c(
                            b(str("policy"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            str("mtu-discovery"),
            str("no-mtu-discovery"),
            str("deaggregate"),
            str("no-deaggregate"),
            str("explicit-null"),
            a(str("label-withdrawal-delay"), arg),
            b(str("make-before-break"),
                c(
                    a(str("timeout"), arg),
                    a(str("switchover-delay"), arg)
                )
            ),
            b(str("transport-address"),
                sc(
                    c(
                      str("router-id"),
                      str("interface"),
                        ipaddr
                    )
                )
            ).as(:oneline),
            a(str("keepalive-interval"), arg),
            a(str("keepalive-timeout"), arg),
            b(a(str("interface"), arg),
                c(
                      (str("disable")),
                    a(str("hello-interval"), arg),
                    a(str("hold-time"), arg),
                    b(str("link-protection"),
                        c(
                              (str("disable")),
                            str("dynamic-rsvp-lsp")
                        )
                    ),
                    b(str("transport-address"),
                        sc(
                            c(
                              str("router-id"),
                              str("interface"),
                                ipaddr
                            )
                        )
                    ).as(:oneline),
                    str("allow-subnet-mismatch"),
                    str("no-allow-subnet-mismatch")
                )
            ),
            a(str("neighbor"), arg),
            b(a(str("session"), arg),
                c(
                    a(str("authentication-key"), arg),
                    b(str("authentication-algorithm"),
                      (str("md5") | str("hmac-sha-1-96") | str("aes-128-cmac-96"))
                    ),
                    a(str("authentication-key-chain"), arg),
                    str("downstream-on-demand"),
                    b(str("transport-address"),
                      ipaddr
                    ),
                    str("mtu-discovery"),
                    str("no-mtu-discovery")
                )
            ),
            b(a(str("session-group"), arg),
                c(
                    a(str("authentication-key"), arg),
                    b(str("authentication-algorithm"),
                      (str("md5") | str("hmac-sha-1-96") | str("aes-128-cmac-96"))
                    ),
                    a(str("authentication-key-chain"), arg),
                    str("downstream-on-demand"),
                    b(str("transport-address"),
                      ipaddr
                    ),
                    str("mtu-discovery"),
                    str("no-mtu-discovery")
                )
            ),
            b(str("session-protection"),
                sc(
                    a(str("timeout"), arg)
                )
            ).as(:oneline),
            b(str("igp-synchronization"),
                c(
                    a(str("holddown-interval"), arg)
                )
            ),
            b(str("log-updown"),
                c(
                    b(str("trap"),
                        sc(
                              (str("disable"))
                        )
                    ).as(:oneline)
                )
            ),
            b(str("policing"),
                c(
                    b(a(str("fec"), arg),
                        c(
                            a(str("ingress-traffic"), arg),
                            a(str("transit-traffic"), arg)
                        )
                    )
                )
            ),
            b(str("entropy-label"),
                c(
                    b(str("ingress-policy"),
                      policy_algebra
                    )
                )
            ),
            b(str("targeted-hello"),
                c(
                    a(str("hello-interval"), arg),
                    a(str("hold-time"), arg)
                )
            ),
            b(str("p2mp"),
                c(
                    b(str("recursive"),
                        c(
                            str("route")
                        )
                    ),
                    b(a(str("root-address"), arg),
                        c(
                            a(str("lsp-id"), arg),
                            b(a(str("group-address"), arg),
                                c(
                                    a(str("source-address"), arg)
                                )
                            )
                        )
                    ),
                    str("no-rsvp-tunneling")
                )
            ),
            b(str("sr-mapping-client"),
                c(
                    b(str("policy"),
                      policy_algebra
                    )
                )
            ),
            str("upstream-label-assignment"),
            a(str("family"), enum(str("inet6") | str("inet"))),
            b(str("transport-preference"),
              (str("ipv4") | str("ipv6"))
            ),
            b(str("dual-transport"),
                c(
                    b(str("inet-lsr-id"),
                      ipv4addr
                    ),
                    b(str("inet6-lsr-id"),
                      ipv4addr
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_lmp) do
        c(
            b(a(str("te-link"), arg),
                c(
                    b(str("local-address"),
                      ipaddr
                    ),
                    b(str("remote-address"),
                      ipaddr
                    ),
                    a(str("remote-id"), arg),
                    a(str("te-metric"), arg),
                      (str("disable")),
                    b(str("ethernet-vlan"),
                        c(
                            a(str("vlan-id-range"), arg)
                        )
                    ),
                    c(
                      b(a(str("interface"), arg),
                          c(
                              b(str("local-address"),
                                ipaddr
                              ),
                              b(str("remote-address"),
                                ipaddr
                              ),
                              a(str("remote-id"), arg),
                                (str("disable"))
                          )
                      ),
                      b(a(str("label-switched-path"), arg),
                          c(
                              b(str("local-address"),
                                ipaddr
                              ),
                              b(str("remote-address"),
                                ipaddr
                              ),
                              a(str("remote-id"), arg),
                                (str("disable"))
                          )
                      )
                    )
                )
            ),
            b(a(str("peer"), arg),
                c(
                    b(str("address"),
                      ipaddr
                    ),
                    b(str("lmp-protocol"),
                        c(
                            a(str("hello-interval"), arg),
                            a(str("hello-dead-interval"), arg),
                            a(str("retransmission-interval"), arg),
                            a(str("retry-limit"), arg),
                            str("passive")
                        )
                    ),
                    b(str("control-channel"),
                      interface_name
                    ),
                    b(str("lmp-control-channel"),
                      lmp_control_channel_type
                    ),
                    a(str("te-link"), arg)
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("init") | str("show") | str("route-socket") | str("parse") | str("process") | str("server") | str("routing") | str("packets") | str("hello-packets") | str("state") | str("nsr-synchronization") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            )
        )
    end

    rule(:juniper_protocols_mpls) do
        c(
            b(a(str("lsp-external-controller"), arg),
                c(
                    b(str("label-switched-path-template"),
                        c(
                            ca(
                              str("default-template")
                            )
                        )
                    ),
                    b(str("label-switched-path-p2mp-template"),
                        c(
                            ca(
                              str("default-template")
                            )
                        )
                    ),
                    b(a(str("pce-controlled-lsp"), arg),
                        c(
                            b(str("label-switched-path-template"),
                                c(
                                      arg
                                )
                            ),
                            b(str("label-switched-path-p2mp-template"),
                                c(
                                      arg
                                )
                            )
                        )
                    )
                )
            ),
            b(str("path-mtu"),
                c(
                    str("allow-fragmentation"),
                    b(str("rsvp"),
                        c(
                            str("mtu-signaling")
                        )
                    )
                )
            ),
            b(str("diffserv-te"),
                c(
                    b(str("bandwidth-model"),
                      (str("extended-mam") | str("mam") | str("rdm"))
                    ),
                    b(str("te-class-matrix"),
                        c(
                            b(str("te0"),
                              te_class_object
                            ).as(:oneline),
                            b(str("te1"),
                              te_class_object
                            ).as(:oneline),
                            b(str("te2"),
                              te_class_object
                            ).as(:oneline),
                            b(str("te3"),
                              te_class_object
                            ).as(:oneline),
                            b(str("te4"),
                              te_class_object
                            ).as(:oneline),
                            b(str("te5"),
                              te_class_object
                            ).as(:oneline),
                            b(str("te6"),
                              te_class_object
                            ).as(:oneline),
                            b(str("te7"),
                              te_class_object
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("auto-policing"),
                c(
                    a(str("class"), enum(str("all") | str("ct0") | str("ct1") | str("ct2") | str("ct3")),
                        c(
                            c(
                              str("drop"),
                              str("loss-priority-high"),
                              str("loss-priority-low")
                            )
                        )
                    )
                )
            ),
            b(str("statistics"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("interval"), arg),
                    str("auto-bandwidth"),
                    str("no-transit-statistics"),
                    c(
                      str("no-transit-statistics-polling"),
                      str("transit-statistics-polling")
                    ),
                    str("no-bypass-statistics-polling"),
                    a(str("statistics-query-batch-size"), arg),
                    str("traffic-class-statistics")
                )
            ),
            b(str("log-updown"),
                c(
                    str("syslog"),
                    str("no-syslog"),
                    c(
                      str("trap"),
                      b(str("no-trap"),
                          c(
                              str("mpls-lsp-traps"),
                              str("rfc3812-traps")
                          )
                      )
                    ),
                    str("trap-path-down"),
                    str("trap-path-up")
                )
            ),
            b(str("optimize-adaptive-teardown"),
                c(
                    str("p2p"),
                    a(str("timeout"), arg),
                    b(str("delay"),
                        c(
                              arg
                        )
                    )
                )
            ),
            b(str("traffic-engineering"),
                c(
                    c(
                      str("bgp"),
                      str("bgp-igp"),
                      str("bgp-igp-both-ribs"),
                      str("mpls-forwarding")
                    ),
                    b(str("database"),
                        c(
                            b(str("import"),
                                c(
                                    b(str("igp-topology"),
                                        c(
                                            str("bgp-link-state")
                                        )
                                    ),
                                    b(str("policy"),
                                      policy_algebra
                                    ),
                                    a(str("identifier"), arg),
                                    a(str("bgp-ls-identifier"), arg)
                                )
                            ),
                            b(str("export"),
                                c(
                                    b(str("policy"),
                                      policy_algebra
                                    ),
                                    b(str("credibility"),
                                        c(
                                            a(str("unknown"), arg),
                                            a(str("direct"), arg),
                                            a(str("static"), arg),
                                            a(str("ospf"), arg),
                                            a(str("isis-level-1"), arg),
                                            a(str("isis-level-2"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("admin-groups"), arg),
                c(
                      arg
                )
            ),
            a(str("advertisement-hold-time"), arg),
            a(str("rsvp-error-hold-time"), arg),
            str("optimize-aggressive"),
            a(str("smart-optimize-timer"), arg),
            a(str("optimize-switchover-delay"), arg),
            str("no-propagate-ttl"),
            str("sensor-based-stats"),
            str("explicit-null"),
            str("icmp-tunneling"),
            a(str("revert-timer"), arg),
            a(str("optimize-hold-dead-delay"), arg),
            str("expand-loose-hop"),
            str("mib-mpls-show-p2mp"),
            b(str("bandwidth"),
              bandwidth_type
            ),
            b(str("admin-group"),
              admin_group_include_exclude
            ),
            b(str("admin-group-extended"),
              admin_group_include_exclude
            ),
        b(str("priority"),
          a(arg, arg)
                
            ),
            b(str("oam"),
              periodic_oam
            ),
            a(str("class-of-service"), arg),
            str("no-decrement-ttl"),
            a(str("hop-limit"), arg),
            str("no-cspf"),
            str("admin-down"),
            a(str("optimize-timer"), arg),
            a(str("preference"), arg),
            str("record"),
            str("no-record"),
            str("standby"),
            str("exclude-srlg"),
            str("ultimate-hop-popping"),
            str("sync-active-path-bandwidth"),
            str("cross-credibility-cspf"),
            b(a(str("label-switched-path"), arg),
                c(
                      (str("disable")),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("cspf-link") | str("cspf-node") | str("cspf") | str("cspf-abstract") | str("state") | str("all"))).as(:oneline)
                        )
                    ),
                    str("no-install-to-address"),
                    str("backup"),
                    b(str("from"),
                      ipv4addr
                    ),
                    str("pop-and-forward"),
                    c(
                      b(str("to"),
                        ipv4addr
                      ),
                      str("template")
                    ),
                    str("corouted-bidirectional"),
                    str("corouted-bidirectional-passive"),
                    a(str("metric"), arg),
                    str("ldp-tunneling"),
                    str("soft-preemption"),
                    b(a(str("install"), arg),
                        sc(
                            str("active")
                        )
                    ).as(:oneline),
                    a(str("retry-timer"), arg),
                    a(str("retry-limit"), arg),
                    b(str("lsp-attributes"),
                        c(
                            b(str("signal-bandwidth"),
                              (str("ds1") | str("vt1-5") | str("e1") | str("vt2") | str("ethernet") | str("e3") | str("ds3") | str("sts-1") | str("fastether") | str("stm-1") | str("stm-4") | str("gigether") | str("stm-16") | str("stm-64") | str("10gigether") | str("stm-256") | str("100gige"))
                            ),
                            b(str("switching-type"),
                              (str("psc-1") | str("lambda") | str("fiber") | str("tdm") | str("ethernet-vlan"))
                            ),
                            b(str("encoding-type"),
                              (str("packet") | str("ethernet") | str("pdh") | str("sonet-sdh"))
                            ),
                            b(str("gpid"),
                              (str("ipv4") | str("ethernet") | str("ppp") | str("hdlc") | str("pos-no-scrambling-crc-16") | str("pos-no-scrambling-crc-32") | str("pos-scrambling-crc-16") | str("pos-scrambling-crc-32"))
                            ),
                            b(str("upstream-label"),
                                c(
                                    a(str("vlan-id"), arg)
                                )
                            )
                        )
                    ),
                    a(str("revert-timer"), arg),
                    a(str("optimize-hold-dead-delay"), arg),
                    b(str("bandwidth"),
                      bandwidth_type
                    ),
                    b(str("admin-group"),
                      admin_group_include_exclude
                    ),
                    b(str("admin-group-extended"),
                      admin_group_include_exclude
                    ),
        b(str("priority"),
          a(arg, arg)
                        
                    ),
                    b(str("oam"),
                      periodic_oam
                    ),
                    a(str("class-of-service"), arg),
                    str("no-decrement-ttl"),
                    a(str("hop-limit"), arg),
                    str("no-cspf"),
                    str("admin-down"),
                    a(str("optimize-timer"), arg),
                    a(str("preference"), arg),
                    str("record"),
                    str("no-record"),
                    str("standby"),
                    str("exclude-srlg"),
                    str("ultimate-hop-popping"),
                    str("sync-active-path-bandwidth"),
                    str("cross-credibility-cspf"),
                    str("entropy-label"),
                    a(str("self-ping-duration"), arg),
                    str("no-self-ping"),
                    c(
                      str("random"),
                      str("least-fill"),
                      str("most-fill")
                    ),
                    a(str("description"), quote | arg),
                    c(
                      str("link-protection"),
                      str("node-link-protection")
                    ),
                    str("intra-domain"),
                    str("inter-domain"),
                    str("adaptive"),
                    b(str("fast-reroute"),
                        c(
                            a(str("hop-limit"), arg),
                            c(
                              a(str("bandwidth"), arg),
                              a(str("bandwidth-percent"), arg)
                            ),
                            c(
                              str("no-include-any"),
                              a(str("include-any"), arg)
                            ),
                            c(
                              str("no-include-all"),
                              a(str("include-all"), arg)
                            ),
                            c(
                              str("no-exclude"),
                              a(str("exclude"), arg)
                            )
                        )
                    ),
                    b(str("p2mp"),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(str("auto-bandwidth"),
                        c(
                            a(str("adjust-interval"), arg),
                            a(str("adjust-threshold"), arg),
                            a(str("adjust-threshold-absolute"), arg),
                            a(str("adjust-threshold-activate-bandwidth"), arg),
                            a(str("minimum-bandwidth"), arg),
                            a(str("maximum-bandwidth"), arg),
                            a(str("minimum-bandwidth-adjust-interval"), arg),
                            a(str("minimum-bandwidth-adjust-threshold-change"), arg),
                            a(str("minimum-bandwidth-adjust-threshold-value"), arg),
                            str("monitor-bandwidth"),
                            a(str("adjust-threshold-overflow-limit"), arg),
                            a(str("adjust-threshold-underflow-limit"), arg),
                            str("resignal-minimum-bandwidth"),
                            str("sync-active-path-bandwidth")
                        )
                    ),
                    b(str("optimize-on-change"),
                        c(
                            str("link-congestion")
                        )
                    ),
                    b(str("deselect-on-bandwidth-failure"),
                        c(
                            str("tear-lsp")
                        )
                    ),
                    b(str("track-igp-metric"),
                        c(
                            str("install-v4-prefixes"),
                            str("install-v6-prefixes")
                        )
                    ),
                    b(str("associate-lsp"),
                        ca(
                            b(str("from"),
                              ipv4addr
                            )
                        )
                    ),
                    b(a(str("primary"), arg),
                        c(
                            b(str("bandwidth"),
                              bandwidth_type
                            ),
                            b(str("admin-group"),
                              admin_group_include_exclude
                            ),
                            b(str("admin-group-extended"),
                              admin_group_include_exclude
                            ),
        b(str("priority"),
          a(arg, arg)
                                
                            ),
                            b(str("oam"),
                              periodic_oam
                            ),
                            a(str("class-of-service"), arg),
                            str("no-decrement-ttl"),
                            a(str("hop-limit"), arg),
                            str("no-cspf"),
                            str("admin-down"),
                            a(str("optimize-timer"), arg),
                            a(str("preference"), arg),
                            str("record"),
                            str("no-record"),
                            str("standby"),
                            str("exclude-srlg"),
                            str("ultimate-hop-popping"),
                            str("sync-active-path-bandwidth"),
                            str("cross-credibility-cspf"),
                            str("adaptive"),
                            b(str("select"),
                              (str("manual") | str("unconditional"))
                            ),
                            b(str("upstream-label"),
                                c(
                                    a(str("vlan-id"), arg)
                                )
                            ),
                            b(str("optimize-on-change"),
                                c(
                                    str("link-congestion")
                                )
                            )
                        )
                    ),
                    b(a(str("secondary"), arg),
                        c(
                            b(str("bandwidth"),
                              bandwidth_type
                            ),
                            b(str("admin-group"),
                              admin_group_include_exclude
                            ),
                            b(str("admin-group-extended"),
                              admin_group_include_exclude
                            ),
        b(str("priority"),
          a(arg, arg)
                                
                            ),
                            b(str("oam"),
                              periodic_oam
                            ),
                            a(str("class-of-service"), arg),
                            str("no-decrement-ttl"),
                            a(str("hop-limit"), arg),
                            str("no-cspf"),
                            str("admin-down"),
                            a(str("optimize-timer"), arg),
                            a(str("preference"), arg),
                            str("record"),
                            str("no-record"),
                            str("standby"),
                            str("exclude-srlg"),
                            str("ultimate-hop-popping"),
                            str("sync-active-path-bandwidth"),
                            str("cross-credibility-cspf"),
                            str("adaptive"),
                            b(str("select"),
                              (str("manual") | str("unconditional"))
                            ),
                            b(str("upstream-label"),
                                c(
                                    a(str("vlan-id"), arg)
                                )
                            ),
                            b(str("optimize-on-change"),
                                c(
                                    str("link-congestion")
                                )
                            )
                        )
                    ),
                    b(str("policing"),
                        sc(
                            a(str("filter"), arg),
                            str("no-auto-policing")
                        )
                    ).as(:oneline),
                    a(str("lsp-external-controller"), arg),
                    str("associate-backup-pe-groups"),
                    str("egress-protection")
                )
            ),
            b(str("deselect-on-bandwidth-failure"),
                c(
                    str("tear-lsp")
                )
            ),
            b(str("track-igp-metric"),
                c(
                    str("install-v4-prefixes"),
                    str("install-v6-prefixes")
                )
            ),
            b(a(str("container-label-switched-path"), arg),
                c(
                      (str("disable")),
                    a(str("description"), quote | arg),
                    b(str("label-switched-path-template"),
                        c(
                            ca(
                              str("default-template")
                            )
                        )
                    ),
                    b(str("to"),
                      ipv4addr
                    ),
                    a(str("suffix"), arg),
                    b(str("splitting-merging"),
                        c(
                            a(str("maximum-member-lsps"), arg),
                            a(str("minimum-member-lsps"), arg),
                            a(str("splitting-bandwidth"), arg),
                            a(str("merging-bandwidth"), arg),
                            a(str("maximum-signaling-bandwidth"), arg),
                            a(str("minimum-signaling-bandwidth"), arg),
                            a(str("splitting-merging-threshold"), arg),
                            b(str("normalization"),
                                c(
                                    a(str("normalize-interval"), arg),
                                    str("failover-normalization"),
                                    str("no-incremental-normalize"),
                                    a(str("normalization-retry-duration"), arg),
                                    a(str("normalization-retry-limits"), arg)
                                )
                            ),
                            b(str("sampling"),
                                c(
                                    a(str("cut-off-threshold"), arg),
                                    c(
                                      str("use-average-aggregate"),
                                      a(str("use-percentile"), arg)
                                    )
                                )
                            )
                        )
                    ),
                    a(str("lsp-external-controller"), arg)
                )
            ),
            b(a(str("transit-lsp-association"), arg),
                c(
                    a(str("lsp-name-1"), arg),
                    b(str("from-1"),
                      ipv4addr
                    ),
                    a(str("lsp-name-2"), arg),
                    b(str("from-2"),
                      ipv4addr
                    )
                )
            ),
        b(a(str("path"), arg),
          c(
            b(
              ipaddr,
              c(
                str("abstract"),
                c(
                  str("loose-link"),
                  str("loose"),
                  str("strict")
                )
              ).as(:oneline)
            )
                
                )
            ),
            b(a(str("constituent-list"), arg),
                c(
                    a(str("srlg"), arg),
                    a(str("admin-group"), arg),
                    a(str("admin-group-extended"), arg)
                )
            ),
            b(a(str("abstract-hop"), arg),
                c(
                    b(str("operator"),
                      (str("AND") | str("OR"))
                    ),
                    b(a(str("constituent-list"), arg),
                        c(
                            c(
                              str("include-any-list"),
                              str("include-all-list"),
                              str("exclude-any-list"),
                              str("exclude-all-list")
                            )
                        )
                    )
                )
            ),
            b(str("egress-protection"),
                c(
                    b(a(str("context-identifier"), arg),
                        c(
                            c(
                              str("primary"),
                              str("protector")
                            ),
                            a(str("metric"), arg),
                            b(str("advertise-mode"),
                              (str("stub-proxy") | str("stub-alias"))
                            ),
                            a(str("admin-group"), arg)
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("state") | str("route") | str("error") | str("all"))).as(:oneline)
                        )
                    )
                )
            ),
            b(str("label-range"),
                c(
                    b(a(str("srgb-label-range"), arg),
                        sc(
                              arg
                        )
                    ).as(:oneline),
                    b(a(str("lsi-label-range"), arg),
                        sc(
                              arg
                        )
                    ).as(:oneline),
                    b(a(str("dynamic-label-range"), arg),
                        sc(
                              arg
                        )
                    ).as(:oneline),
                    b(a(str("block-label-range"), arg),
                        sc(
                              arg
                        )
                    ).as(:oneline),
                    a(str("label-limit"), arg),
                    b(a(str("static-label-range"), arg),
                        sc(
                              arg
                        )
                    ).as(:oneline)
                )
            ),
              (str("disable")),
            b(str("label-history"),
                c(
                    a(str("max-entries"), arg)
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("connection") | str("connection-detail") | str("cspf-link") | str("cspf-node") | str("cspf") | str("cspf-abstract") | str("state") | str("error") | str("lsping") | str("graceful-restart") | str("nsr-synchronization") | str("nsr-synchronization-detail") | str("static") | str("egress-protection") | str("all") | str("autobw-state") | str("externally-controlled-lsp") | str("ted-import") | str("ted-export") | str("lsp-history") | str("abstract-hop"))).as(:oneline)
                )
            ),
            str("ipv6-tunneling"),
            b(str("interface"),
              juniper_protocols_mpls_interface
            ),
            b(a(str("static-label-switched-path"), arg),
                c(
                    c(
                      b(str("bypass"),
                          c(
                              a(str("bandwidth"), arg),
                              a(str("description"), quote | arg),
                              b(str("next-hop"),
                                ipaddr_or_interface
                              ),
                              a(str("next-table"), arg),
                              a(str("push"), arg),
                              b(str("to"),
                                ipaddr
                              )
                          )
                      ),
                      b(a(str("transit"), arg),
                          c(
                              a(str("bandwidth"), arg),
                              a(str("description"), quote | arg),
                              b(str("link-protection"),
                                  sc(
                                      a(str("bypass-name"), arg)
                                  )
                              ).as(:oneline),
                              b(str("next-hop"),
                                ipaddr_or_interface
                              ),
                              b(str("member-interface"),
                                interface_unit
                              ),
                              b(str("node-protection"),
                                  sc(
                                      a(str("bypass-name"), arg),
                                      a(str("next-next-label"), arg)
                                  )
                              ).as(:oneline),
                              c(
                                a(str("swap"), arg),
                                str("pop"),
                                str("stitch")
                              )
                          )
                      ),
                      b(str("ingress"),
                          c(
                              a(str("bandwidth"), arg),
                              a(str("class-of-service"), arg),
                              a(str("description"), quote | arg),
                              b(a(str("install"), arg),
                                  sc(
                                      str("active")
                                  )
                              ).as(:oneline),
                              a(str("metric"), arg),
                              b(str("next-hop"),
                                ipv4addr_or_interface
                              ),
                              b(str("link-protection"),
                                  sc(
                                      a(str("bypass-name"), arg)
                                  )
                              ).as(:oneline),
                              b(str("node-protection"),
                                  sc(
                                      a(str("bypass-name"), arg),
                                      a(str("next-next-label"), arg)
                                  )
                              ).as(:oneline),
                              str("no-install-to-address"),
                              b(str("policing"),
                                  sc(
                                      a(str("filter"), arg),
                                      str("no-auto-policing")
                                  )
                              ).as(:oneline),
                              a(str("preference"), arg),
                              b(str("to"),
                                ipv4addr
                              ),
                              a(str("push"), arg),
                              str("entropy-label")
                          )
                      ),
                      b(str("segment"),
                          ca(
                              a(str("description"), quote | arg),
                              b(str("next-hop"),
                                ipv4addr_or_interface
                              ),
                              c(
                                a(str("swap"), arg),
                                str("pop")
                              )
                          )
                      )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_mpls_interface) do
      b(arg.as(:arg),
        c(
              (str("disable")),
            a(str("srlg"), arg),
            str("always-mark-connection-protection-tlv"),
            str("switch-away-lsps"),
            a(str("admin-group"), arg),
            a(str("admin-group-extended"), arg),
            b(str("static"),
                c(
                    a(str("protection-revert-time"), arg)
                )
            )
        )
      )
    end

    rule(:juniper_protocols_msdp) do
        c(
            b(str("data-encapsulation"),
              (str("disable") | str("enable"))
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("active-source-limit"),
                c(
                    a(str("maximum"), arg),
                    a(str("threshold"), arg),
                    a(str("log-warning"), arg),
                    a(str("log-interval"), arg)
                )
            ),
              (str("disable")),
            b(str("export"),
              policy_algebra
            ),
            b(str("import"),
              policy_algebra
            ),
            b(str("local-address"),
              ipv4addr
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("route") | str("nsr-synchronization") | str("source-active") | str("source-active-request") | str("source-active-response") | str("keepalive") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("peer"), arg),
                c(
                      (str("disable")),
                    b(str("export"),
                      policy_algebra
                    ),
                    b(str("import"),
                      policy_algebra
                    ),
                    b(str("local-address"),
                      ipv4addr
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("packets") | str("route") | str("nsr-synchronization") | str("source-active") | str("source-active-request") | str("source-active-response") | str("keepalive") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("active-source-limit"),
                        c(
                            a(str("maximum"), arg),
                            a(str("threshold"), arg),
                            a(str("log-warning"), arg),
                            a(str("log-interval"), arg)
                        )
                    ),
                    a(str("keep-alive"), arg),
                    a(str("hold-time"), arg),
                    a(str("sa-hold-time"), arg),
                    str("default-peer"),
                    a(str("authentication-key"), arg)
                )
            ),
            a(str("keep-alive"), arg),
            a(str("hold-time"), arg),
            a(str("sa-hold-time"), arg),
            b(a(str("source"), arg),
                c(
                    b(str("active-source-limit"),
                        c(
                            a(str("maximum"), arg),
                            a(str("threshold"), arg),
                            a(str("log-warning"), arg),
                            a(str("log-interval"), arg)
                        )
                    )
                )
            ),
            b(a(str("group"), arg),
                c(
                    b(str("mode"),
                      (str("standard") | str("mesh-group"))
                    ),
                      (str("disable")),
                    b(str("export"),
                      policy_algebra
                    ),
                    b(str("import"),
                      policy_algebra
                    ),
                    b(str("local-address"),
                      ipv4addr
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("packets") | str("route") | str("nsr-synchronization") | str("source-active") | str("source-active-request") | str("source-active-response") | str("keepalive") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("peer"), arg),
                        c(
                              (str("disable")),
                            b(str("export"),
                              policy_algebra
                            ),
                            b(str("import"),
                              policy_algebra
                            ),
                            b(str("local-address"),
                              ipv4addr
                            ),
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("packets") | str("route") | str("nsr-synchronization") | str("source-active") | str("source-active-request") | str("source-active-response") | str("keepalive") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                        sc(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("active-source-limit"),
                                c(
                                    a(str("maximum"), arg),
                                    a(str("threshold"), arg),
                                    a(str("log-warning"), arg),
                                    a(str("log-interval"), arg)
                                )
                            ),
                            a(str("keep-alive"), arg),
                            a(str("hold-time"), arg),
                            a(str("sa-hold-time"), arg),
                            str("default-peer"),
                            a(str("authentication-key"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_mstp) do
        c(
              (str("disable")),
            b(str("bpdu-destination-mac-address"),
              (str("provider-bridge-group"))
            ),
            a(str("configuration-name"), arg),
            a(str("revision-level"), arg),
            a(str("max-hops"), arg),
            a(str("max-age"), arg),
            a(str("hello-time"), arg),
            a(str("forward-delay"), arg),
            b(str("system-identifier"),
              mac_unicast
            ),
            b(str("traceoptions"),
              stp_trace_options
            ),
            a(str("bridge-priority"), arg),
            a(str("backup-bridge-priority"), arg),
            str("bpdu-block-on-edge"),
            str("vpls-flush-on-topology-change"),
            a(str("priority-hold-time"), arg),
            b(str("system-id"),
              system_id_ip_map
            ),
            b(str("interface"),
              mstp_interface
            ),
            b(a(str("msti"), arg),
                c(
                    a(str("bridge-priority"), arg),
                    a(str("backup-bridge-priority"), arg),
                    a(str("vlan"), arg),
                    b(str("interface"),
                      mstp_interface
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_mvpn) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("error") | str("nlri") | str("topology") | str("tunnel") | str("umh") | str("intra-as-ad") | str("inter-as-ad") | str("spmsi-ad") | str("leaf-ad") | str("source-active") | str("cmcast-join") | str("mdt-safi-ad") | str("mvpn-limit") | str("nsr-synchronization") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("autodiscovery-only"),
                c(
                    b(str("intra-as"),
                        c(
                            str("inclusive")
                        )
                    )
                )
            ),
            b(str("family"),
                c(
                    b(str("any"),
                        c(
                            str("disable")
                        )
                    ),
                    b(str("inet"),
                        c(
                            b(str("autodiscovery-only"),
                                c(
                                    b(str("intra-as"),
                                        c(
                                            str("inclusive")
                                        )
                                    )
                                )
                            ),
                            str("disable")
                        )
                    ),
                    b(str("inet6"),
                        c(
                            b(str("autodiscovery-only"),
                                c(
                                    b(str("intra-as"),
                                        c(
                                            str("inclusive")
                                        )
                                    )
                                )
                            ),
                            str("disable")
                        )
                    )
                )
            ),
            c(
              str("receiver-site"),
              str("sender-site")
            ),
            str("unicast-umh-election"),
            b(str("static-umh"),
                c(
                    b(str("primary"),
                      ipv4addr
                    ),
                    b(str("backup"),
                      ipv4addr
                    ),
                    c(
                      str("source-tree")
                    )
                )
            ),
            a(str("cmcast-joins-limit-inet"), arg),
            a(str("cmcast-joins-limit-inet6"), arg),
            b(str("mvpn-mode"),
                c(
                    c(
                      b(str("rpt-spt"),
                          c(
                              a(str("spt-switch-timer"), arg)
                          )
                      ),
                      b(str("spt-only"),
                          c(
                              b(str("source-active-advertisement"),
                                  c(
                                      a(str("dampen"), arg),
                                      a(str("min-rate"), arg)
                                  )
                              ),
                              str("convert-sa-to-msdp")
                          )
                      )
                    )
                )
            ),
            b(str("route-target"),
                c(
                    b(str("import-target"),
                        c(
                            b(str("unicast"),
                                sc(
                                    c(
                                      str("receiver"),
                                      str("sender")
                                    )
                                )
                            ).as(:oneline),
                            b(str("target"),
                                sc(
                                    arg,
                                    c(
                                      str("receiver"),
                                      str("sender")
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("export-target"),
                        c(
                            str("unicast"),
                            a(str("target"), arg)
                        )
                    )
                )
            ),
            b(str("mvpn-join-load-balance"),
                c(
                    c(
                      str("bytewise-xor-hash")
                    )
                )
            ),
            str("install-discard"),
            str("sender-based-rpf"),
            b(str("hot-root-standby"),
                c(
                    c(
                      str("source-tree")
                    ),
                    b(str("min-rate"),
                        c(
                            a(str("rate"), arg),
                            a(str("revert-delay"), arg)
                        )
                    )
                )
            ),
            str("hierarchical-nexthop"),
            str("no-nexthop-sharing-for-selective-tunnel"),
            b(str("inter-region-template"),
                c(
                    b(a(str("template"), arg),
                        c(
                            b(a(str("region"), arg),
                                c(
                                    c(
                                      b(str("rsvp-te"),
                                          c(
                                              c(
                                                a(str("static-lsp"), arg),
                                                b(str("label-switched-path-template"),
                                                    c(
                                                        ca(
                                                          str("default-template")
                                                        )
                                                    )
                                                )
                                              )
                                          )
                                      ),
                                      str("ldp-p2mp"),
                                      b(str("ingress-replication"),
                                          c(
                                              str("create-new-ucast-tunnel"),
                                              b(str("label-switched-path"),
                                                  c(
                                                      b(str("label-switched-path-template"),
                                                          c(
                                                              ca(
                                                                str("default-template")
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      str("incoming")
                                    )
                                )
                            ),
                            b(str("all-regions"),
                                c(
                                    c(
                                      b(str("rsvp-te"),
                                          c(
                                              c(
                                                a(str("static-lsp"), arg),
                                                b(str("label-switched-path-template"),
                                                    c(
                                                        ca(
                                                          str("default-template")
                                                        )
                                                    )
                                                )
                                              )
                                          )
                                      ),
                                      str("ldp-p2mp"),
                                      b(str("ingress-replication"),
                                          c(
                                              str("create-new-ucast-tunnel"),
                                              b(str("label-switched-path"),
                                                  c(
                                                      b(str("label-switched-path-template"),
                                                          c(
                                                              ca(
                                                                str("default-template")
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      str("incoming")
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            str("source-redundancy"),
            b(str("umh-selection-additional-input"),
                c(
                    str("source-active-preference"),
                    str("tunnel-status")
                )
            )
        )
    end

    rule(:juniper_protocols_mvrp) do
        c(
            b(str("traceoptions"),
              mrp_trace_options
            ),
            a(str("join-timer"), arg),
            a(str("leave-timer"), arg),
            a(str("leaveall-timer"), arg),
            str("no-dynamic-vlan"),
            str("no-attribute-length-in-pdu"),
            b(str("bpdu-destination-mac-address"),
              (str("provider-bridge-group"))
            ),
            b(a(str("interface"), arg),
                c(
                    a(str("join-timer"), arg),
                    a(str("leave-timer"), arg),
                    a(str("leaveall-timer"), arg),
                    str("point-to-point"),
                    b(str("registration"),
                      (str("normal") | str("restricted") | str("forbidden"))
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_openflow) do
        c(
            b(a(str("switch"), arg),
                c(
                    b(str("default-action"),
                        c(
                            c(
                              str("drop"),
                              str("packet-in")
                            )
                        )
                    ),
                    b(a(str("interfaces"), arg),
                        sc(
                            a(str("port-id"), arg)
                        )
                    ).as(:oneline),
                    a(str("purge-flow-timer"), arg),
                    b(str("controller"),
                        c(
                            b(str("protocol"),
                                c(
                                    b(str("tcp"),
                                        c(
                                            a(str("port"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("role"),
                              (str("equal"))
                            ),
                            b(str("address"),
                              ipaddr
                            ),
                            a(str("id"), arg)
                        )
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("switch") | str("configuration") | str("flow") | str("filter") | str("function") | str("packet-io") | str("statistics") | str("interface") | str("packets") | str("barrier") | str("nh") | str("group") | str("all"))).as(:oneline)
                )
            )
        )
    end

    rule(:juniper_protocols_ospf) do
        c(
            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                c(
                    str("disable"),
                    a(str("topology-id"), arg),
                    str("overload"),
                    a(str("rib-group"), arg),
                    b(str("spf-options"),
                        c(
                            a(str("delay"), arg),
                            a(str("holddown"), arg),
                            a(str("rapid-runs"), arg),
                            str("no-ignore-our-externals")
                        )
                    ),
                    b(str("backup-spf-options"),
                        c(
                            b(str("remote-backup-calculation"),
                                c(
                                    b(str("pq-nodes-nearest-to-source"),
                                        c(
                                            a(str("percent"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("use-post-convergence-lfa"),
                                c(
                                    a(str("maximum-labels"), arg),
                                    a(str("maximum-backup-paths"), arg)
                                )
                            ),
                            str("use-source-packet-routing"),
                            str("disable"),
                            str("no-install"),
                            str("downstream-paths-only"),
                            b(str("per-prefix-calculation"),
                                c(
                                    str("stubs"),
                                    str("summary"),
                                    str("externals"),
                                    str("all")
                                )
                            ),
                            str("node-link-degradation")
                        )
                    ),
                    a(str("prefix-export-limit"), arg)
                )
            ),
            b(str("backup-spf-options"),
                c(
                    b(str("remote-backup-calculation"),
                        c(
                            b(str("pq-nodes-nearest-to-source"),
                                c(
                                    a(str("percent"), arg)
                                )
                            )
                        )
                    ),
                    b(str("use-post-convergence-lfa"),
                        c(
                            a(str("maximum-labels"), arg),
                            a(str("maximum-backup-paths"), arg)
                        )
                    ),
                    str("use-source-packet-routing"),
                    str("disable"),
                    str("no-install"),
                    str("downstream-paths-only"),
                    b(str("per-prefix-calculation"),
                        c(
                            str("stubs"),
                            str("summary"),
                            str("externals"),
                            str("all")
                        )
                    ),
                    str("node-link-degradation")
                )
            ),
            b(str("traffic-engineering"),
                c(
                    str("no-topology"),
                    str("multicast-rpf-routes"),
                    str("igp-topology"),
                    str("ignore-lsp-metrics"),
                    b(str("shortcuts"),
                        c(
                            str("ignore-lsp-metrics"),
                            str("lsp-metric-into-summary"),
                            a(str("family"), enum(str("inet") | str("inet-mpls")))
                        )
                    ),
                    str("advertise-unnumbered-interfaces"),
                    str("credibility-protocol-preference"),
                    b(str("advertisement"),
                        c(
                            str("always")
                        )
                    )
                )
            ),
            b(str("source-packet-routing"),
                c(
                    b(str("adjacency-segment"),
                        c(
                            a(str("hold-time"), arg)
                        )
                    ),
                    b(str("prefix-segment"),
                      policy_algebra
                    ),
                    str("explicit-null"),
                    b(str("node-segment"),
                        c(
                            a(str("ipv4-index"), arg),
                            a(str("index-range"), arg)
                        )
                    ),
                    b(str("srgb"),
                        sc(
                            a(str("start-label"), arg),
                            a(str("index-range"), arg)
                        )
                    ).as(:oneline),
                    a(str("mapping-server"), arg),
                    str("install-prefix-sid-for-best-route"),
                    str("ldp-stitching")
                )
            ),
            b(a(str("area"), arg),
                c(
                    c(
                      b(str("stub"),
                          sc(
                              a(str("default-metric"), arg),
                              str("summaries"),
                              str("no-summaries")
                          )
                      ).as(:oneline),
                      b(str("nssa"),
                          c(
                              b(str("default-lsa"),
                                  c(
                                      a(str("default-metric"), arg),
                                      a(str("metric-type"), arg),
                                      str("type-7")
                                  )
                              ),
                              a(str("default-metric"), arg),
                              a(str("metric-type"), arg),
                              str("summaries"),
                              str("no-summaries"),
                              b(a(str("area-range"), arg),
                                  c(
                                      str("restrict"),
                                      str("exact"),
                                      b(str("override-metric"),
                                          ca(
                                              a(str("metric-type"), arg)
                                          )
                                      )
                                  )
                              )
                          )
                      )
                    ),
                    b(a(str("area-range"), arg),
                        c(
                            str("restrict"),
                            str("exact"),
                            a(str("override-metric"), arg)
                        )
                    ),
                    b(str("network-summary-export"),
                      policy_algebra
                    ),
                    b(str("network-summary-import"),
                      policy_algebra
                    ),
                    b(str("inter-area-prefix-export"),
                      policy_algebra
                    ),
                    b(str("inter-area-prefix-import"),
                      policy_algebra
                    ),
                    b(str("authentication-type"),
                      (str("none") | str("simple") | str("md5"))
                    ),
                    b(str("virtual-link"),
                        s(
                          a(str("neighbor-id"), arg),
                          a(str("transit-area"), arg),
                          c(
                              (str("disable")),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            a(str("mtu"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              ),
                              b(str("authentication-key"),
                                  sc(
                                        unreadable,
                                      a(str("key-id"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            str("no-neighbor-down-notification"),
                            a(str("ipsec-sa"), arg),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                          )
                        )
                    ),
                    b(a(str("sham-link-remote"), arg),
                        c(
                            a(str("metric"), arg),
                            a(str("ipsec-sa"), arg),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("interface"), arg),
                        c(
                              (str("disable")),
                            b(str("interface-type"),
                              (str("nbma") | str("p2mp") | str("p2p") | str("p2mp-over-lan"))
                            ),
                            c(
                              str("link-protection"),
                              str("node-link-protection")
                            ),
                            str("no-eligible-backup"),
                            str("no-eligible-remote-backup"),
                            b(str("passive"),
                                c(
                                    b(str("traffic-engineering"),
                                        c(
                                            b(str("remote-node-id"),
                                              ipaddr
                                            ),
                                            b(str("remote-node-router-id"),
                                              ipv4addr
                                            )
                                        )
                                    )
                                )
                            ),
                            str("secondary"),
                            str("own-router-lsa"),
                            b(str("bandwidth-based-metrics"),
                                c(
                                    b(a(str("bandwidth"), arg),
                                        sc(
                                            a(str("metric"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            a(str("metric"), arg),
                            a(str("priority"), arg),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            a(str("mtu"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              ),
                              b(str("authentication-key"),
                                  sc(
                                        unreadable,
                                      a(str("key-id"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            str("no-neighbor-down-notification"),
                            a(str("ipsec-sa"), arg),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            a(str("transmit-interval"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("authentication"),
                                        c(
                                            a(str("key-chain"), arg),
                                            b(str("algorithm"),
                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                            ),
                                            str("loose-check")
                                        )
                                    ),
                                    str("full-neighbors-only")
                                )
                            ),
                            str("dynamic-neighbors"),
                            str("no-advertise-adjacency-segment"),
                            b(a(str("neighbor"), arg),
                                sc(
                                    str("eligible")
                                )
                            ).as(:oneline),
                            a(str("poll-interval"), arg),
                            str("no-interface-state-traps"),
                            b(str("post-convergence-lfa"),
                                c(
                                    b(str("node-protection"),
                                        c(
                                            a(str("cost"), arg)
                                        )
                                    )
                                )
                            ),
                            a(str("te-metric"), arg),
                            b(str("ldp-synchronization"),
                              ldp_sync_obj
                            ),
                            b(str("ipv4-adjacency-segment"),
                                c(
                                    b(str("protected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("unprotected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(a(str("lan-neighbor"), arg),
                                c(
                                    b(str("ipv4-adjacency-segment"),
                                        c(
                                            b(str("protected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("unprotected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("no-context-identifier-advertisement"),
                    b(a(str("peer-interface"), arg),
                        c(
                              (str("disable")),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            a(str("mtu"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              ),
                              b(str("authentication-key"),
                                  sc(
                                        unreadable,
                                      a(str("key-id"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            str("no-neighbor-down-notification")
                        )
                    ),
                    str("no-source-packet-routing"),
                    a(str("context-identifier"), arg),
                    b(a(str("label-switched-path"), arg),
                        c(
                              (str("disable")),
                            a(str("metric"), arg),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
              (str("disable")),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("spf") | str("error") | str("event") | str("packet-dump") | str("flooding") | str("lsa-analysis") | str("packets") | str("hello") | str("database-description") | str("lsa-request") | str("lsa-update") | str("lsa-ack") | str("ldp-synchronization") | str("on-demand") | str("nsr-synchronization") | str("graceful-restart") | str("restart-signaling") | str("backup-spf") | str("source-packet-routing") | str("post-convergence-lfa") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("spf-options"),
                c(
                    a(str("delay"), arg),
                    a(str("holddown"), arg),
                    a(str("rapid-runs"), arg),
                    str("no-ignore-our-externals")
                )
            ),
            a(str("prefix-export-limit"), arg),
            b(str("rib-groups"),
                c(
                    a(str("inet"), arg),
                    a(str("inet3"), arg)
                )
            ),
            str("job-stats"),
            b(str("overload"),
                c(
                    a(str("timeout"), arg),
                    str("allow-route-leaking"),
                    str("stub-network"),
                    str("intra-area-prefix"),
                    str("as-external")
                )
            ),
            b(str("database-protection"),
                c(
                    a(str("maximum-lsa"), arg),
                    str("warning-only"),
                    a(str("warning-threshold"), arg),
                    a(str("ignore-count"), arg),
                    a(str("ignore-time"), arg),
                    a(str("reset-time"), arg)
                )
            ),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-duration"), arg),
                    a(str("notify-duration"), arg),
                    b(str("helper-disable"),
                        c(
                            c(
                              str("standard"),
                              str("restart-signaling"),
                              str("both")
                            )
                        )
                    ),
                    str("no-strict-lsa-checking")
                )
            ),
            b(str("route-type-community"),
              (str("iana") | str("vendor"))
            ),
            b(str("domain-id"),
                sc(
                    ca(
                      str("disable")
                    )
                )
            ).as(:oneline),
            c(
              a(str("domain-vpn-tag"), arg),
              str("no-domain-vpn-tag")
            ),
            a(str("preference"), arg),
            a(str("external-preference"), arg),
            a(str("labeled-preference"), arg),
            b(str("export"),
              policy_algebra
            ),
            b(str("import"),
              policy_algebra
            ),
            a(str("reference-bandwidth"), arg),
            a(str("lsa-refresh-interval"), arg),
            a(str("spf-delay"), arg),
            str("no-rfc-1583"),
            str("forwarding-address-to-broadcast"),
            c(
              str("no-nssa-abr")
            ),
            b(str("sham-link"),
                c(
                    b(str("local"),
                      ipaddr
                    ),
                    str("no-advertise-local")
                )
            )
        )
    end

    rule(:juniper_ospf_authentication) do
        c(
            c(
              b(str("simple-password"),
                unreadable
              ),
              b(a(str("md5"), arg),
                  sc(
                      b(str("key"),
                        unreadable
                      ),
                      b(str("start-time"),
                        time
                      )
                  )
              ).as(:oneline)
            )
        )
    end

    rule(:juniper_protocols_ospf3) do
        c(
            a(str("realm"), str("ipv6-unicast") | str("ipv6-multicast") | str("ipv4-unicast") | str("ipv4-multicast"),
                c(
                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                        c(
                            str("disable"),
                            a(str("topology-id"), arg),
                            str("overload"),
                            a(str("rib-group"), arg),
                            b(str("spf-options"),
                                c(
                                    a(str("delay"), arg),
                                    a(str("holddown"), arg),
                                    a(str("rapid-runs"), arg),
                                    str("no-ignore-our-externals")
                                )
                            ),
                            b(str("backup-spf-options"),
                                c(
                                    b(str("remote-backup-calculation"),
                                        c(
                                            b(str("pq-nodes-nearest-to-source"),
                                                c(
                                                    a(str("percent"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("use-post-convergence-lfa"),
                                        c(
                                            a(str("maximum-labels"), arg),
                                            a(str("maximum-backup-paths"), arg)
                                        )
                                    ),
                                    str("use-source-packet-routing"),
                                    str("disable"),
                                    str("no-install"),
                                    str("downstream-paths-only"),
                                    b(str("per-prefix-calculation"),
                                        c(
                                            str("stubs"),
                                            str("summary"),
                                            str("externals"),
                                            str("all")
                                        )
                                    ),
                                    str("node-link-degradation")
                                )
                            ),
                            a(str("prefix-export-limit"), arg)
                        )
                    ),
                    b(str("backup-spf-options"),
                        c(
                            b(str("remote-backup-calculation"),
                                c(
                                    b(str("pq-nodes-nearest-to-source"),
                                        c(
                                            a(str("percent"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("use-post-convergence-lfa"),
                                c(
                                    a(str("maximum-labels"), arg),
                                    a(str("maximum-backup-paths"), arg)
                                )
                            ),
                            str("use-source-packet-routing"),
                            str("disable"),
                            str("no-install"),
                            str("downstream-paths-only"),
                            b(str("per-prefix-calculation"),
                                c(
                                    str("stubs"),
                                    str("summary"),
                                    str("externals"),
                                    str("all")
                                )
                            ),
                            str("node-link-degradation")
                        )
                    ),
                    b(str("traffic-engineering"),
                        c(
                            str("no-topology"),
                            str("multicast-rpf-routes"),
                            str("igp-topology"),
                            str("ignore-lsp-metrics"),
                            b(str("shortcuts"),
                                c(
                                    str("ignore-lsp-metrics"),
                                    str("lsp-metric-into-summary"),
                                    a(str("family"), enum(str("inet") | str("inet-mpls")))
                                )
                            ),
                            str("advertise-unnumbered-interfaces"),
                            str("credibility-protocol-preference"),
                            b(str("advertisement"),
                                c(
                                    str("always")
                                )
                            )
                        )
                    ),
                    b(str("source-packet-routing"),
                        c(
                            b(str("adjacency-segment"),
                                c(
                                    a(str("hold-time"), arg)
                                )
                            ),
                            b(str("prefix-segment"),
                              policy_algebra
                            ),
                            str("explicit-null"),
                            b(str("node-segment"),
                                c(
                                    a(str("ipv4-index"), arg),
                                    a(str("index-range"), arg)
                                )
                            ),
                            b(str("srgb"),
                                sc(
                                    a(str("start-label"), arg),
                                    a(str("index-range"), arg)
                                )
                            ).as(:oneline),
                            a(str("mapping-server"), arg),
                            str("install-prefix-sid-for-best-route"),
                            str("ldp-stitching")
                        )
                    ),
                    b(a(str("area"), arg),
                        c(
                            c(
                              b(str("stub"),
                                  sc(
                                      a(str("default-metric"), arg),
                                      str("summaries"),
                                      str("no-summaries")
                                  )
                              ).as(:oneline),
                              b(str("nssa"),
                                  c(
                                      b(str("default-lsa"),
                                          c(
                                              a(str("default-metric"), arg),
                                              a(str("metric-type"), arg),
                                              str("type-7")
                                          )
                                      ),
                                      a(str("default-metric"), arg),
                                      a(str("metric-type"), arg),
                                      str("summaries"),
                                      str("no-summaries"),
                                      b(a(str("area-range"), arg),
                                          c(
                                              str("restrict"),
                                              str("exact"),
                                              b(str("override-metric"),
                                                  ca(
                                                      a(str("metric-type"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                            ),
                            b(a(str("area-range"), arg),
                                c(
                                    str("restrict"),
                                    str("exact"),
                                    a(str("override-metric"), arg)
                                )
                            ),
                            b(str("network-summary-export"),
                              policy_algebra
                            ),
                            b(str("network-summary-import"),
                              policy_algebra
                            ),
                            b(str("inter-area-prefix-export"),
                              policy_algebra
                            ),
                            b(str("inter-area-prefix-import"),
                              policy_algebra
                            ),
                            b(str("authentication-type"),
                              (str("none") | str("simple") | str("md5"))
                            ),
                            b(str("virtual-link"),
                                s(
                                  a(str("neighbor-id"), arg),
                                  a(str("transit-area"), arg),
                                  c(
                                      (str("disable")),
                                    a(str("retransmit-interval"), arg),
                                    a(str("transit-delay"), arg),
                                    a(str("hello-interval"), arg),
                                    a(str("dead-interval"), arg),
                                    a(str("mtu"), arg),
                                    c(
                                      b(str("authentication"),
                                        juniper_ospf_authentication
                                      ),
                                      b(str("authentication-key"),
                                          sc(
                                                unreadable,
                                              a(str("key-id"), arg)
                                          )
                                      ).as(:oneline)
                                    ),
                                    str("demand-circuit"),
                                    str("flood-reduction"),
                                    str("no-neighbor-down-notification"),
                                    a(str("ipsec-sa"), arg),
                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                        c(
                                            str("disable"),
                                            a(str("metric"), arg),
                                            b(str("bandwidth-based-metrics"),
                                                c(
                                                    b(a(str("bandwidth"), arg),
                                                        sc(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    )
                                  )
                                )
                            ),
                            b(a(str("sham-link-remote"), arg),
                                c(
                                    a(str("metric"), arg),
                                    a(str("ipsec-sa"), arg),
                                    str("demand-circuit"),
                                    str("flood-reduction"),
                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                        c(
                                            str("disable"),
                                            a(str("metric"), arg),
                                            b(str("bandwidth-based-metrics"),
                                                c(
                                                    b(a(str("bandwidth"), arg),
                                                        sc(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("interface"), arg),
                                c(
                                      (str("disable")),
                                    b(str("interface-type"),
                                      (str("nbma") | str("p2mp") | str("p2p") | str("p2mp-over-lan"))
                                    ),
                                    c(
                                      str("link-protection"),
                                      str("node-link-protection")
                                    ),
                                    str("no-eligible-backup"),
                                    str("no-eligible-remote-backup"),
                                    b(str("passive"),
                                        c(
                                            b(str("traffic-engineering"),
                                                c(
                                                    b(str("remote-node-id"),
                                                      ipaddr
                                                    ),
                                                    b(str("remote-node-router-id"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    str("secondary"),
                                    str("own-router-lsa"),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    a(str("metric"), arg),
                                    a(str("priority"), arg),
                                    a(str("retransmit-interval"), arg),
                                    a(str("transit-delay"), arg),
                                    a(str("hello-interval"), arg),
                                    a(str("dead-interval"), arg),
                                    a(str("mtu"), arg),
                                    c(
                                      b(str("authentication"),
                                        juniper_ospf_authentication
                                      ),
                                      b(str("authentication-key"),
                                          sc(
                                                unreadable,
                                              a(str("key-id"), arg)
                                          )
                                      ).as(:oneline)
                                    ),
                                    str("demand-circuit"),
                                    str("flood-reduction"),
                                    str("no-neighbor-down-notification"),
                                    a(str("ipsec-sa"), arg),
                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                        c(
                                            str("disable"),
                                            a(str("metric"), arg),
                                            b(str("bandwidth-based-metrics"),
                                                c(
                                                    b(a(str("bandwidth"), arg),
                                                        sc(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    a(str("transmit-interval"), arg),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("version"),
                                              (str("0") | str("1") | str("automatic"))
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("minimum-transmit-interval"), arg),
                                            a(str("minimum-receive-interval"), arg),
                                            a(str("multiplier"), arg),
                                            c(
                                              str("no-adaptation")
                                            ),
                                            b(str("transmit-interval"),
                                                c(
                                                    a(str("minimum-interval"), arg),
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("detection-time"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("authentication"),
                                                c(
                                                    a(str("key-chain"), arg),
                                                    b(str("algorithm"),
                                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                    ),
                                                    str("loose-check")
                                                )
                                            ),
                                            str("full-neighbors-only")
                                        )
                                    ),
                                    str("dynamic-neighbors"),
                                    str("no-advertise-adjacency-segment"),
                                    b(a(str("neighbor"), arg),
                                        sc(
                                            str("eligible")
                                        )
                                    ).as(:oneline),
                                    a(str("poll-interval"), arg),
                                    str("no-interface-state-traps"),
                                    b(str("post-convergence-lfa"),
                                        c(
                                            b(str("node-protection"),
                                                c(
                                                    a(str("cost"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    a(str("te-metric"), arg),
                                    b(str("ldp-synchronization"),
                                      ldp_sync_obj
                                    ),
                                    b(str("ipv4-adjacency-segment"),
                                        c(
                                            b(str("protected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("unprotected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(a(str("lan-neighbor"), arg),
                                        c(
                                            b(str("ipv4-adjacency-segment"),
                                                c(
                                                    b(str("protected"),
                                                        sc(
                                                            c(
                                                              b(str("index"),
                                                                  sc(
                                                                        arg
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("label"), arg),
                                                              str("dynamic")
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    b(str("unprotected"),
                                                        sc(
                                                            c(
                                                              b(str("index"),
                                                                  sc(
                                                                        arg
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("label"), arg),
                                                              str("dynamic")
                                                            )
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            str("no-context-identifier-advertisement"),
                            b(a(str("peer-interface"), arg),
                                c(
                                      (str("disable")),
                                    a(str("retransmit-interval"), arg),
                                    a(str("transit-delay"), arg),
                                    a(str("hello-interval"), arg),
                                    a(str("dead-interval"), arg),
                                    a(str("mtu"), arg),
                                    c(
                                      b(str("authentication"),
                                        juniper_ospf_authentication
                                      ),
                                      b(str("authentication-key"),
                                          sc(
                                                unreadable,
                                              a(str("key-id"), arg)
                                          )
                                      ).as(:oneline)
                                    ),
                                    str("demand-circuit"),
                                    str("flood-reduction"),
                                    str("no-neighbor-down-notification")
                                )
                            ),
                            str("no-source-packet-routing"),
                            a(str("context-identifier"), arg),
                            b(a(str("label-switched-path"), arg),
                                c(
                                      (str("disable")),
                                    a(str("metric"), arg),
                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                        c(
                                            str("disable"),
                                            a(str("metric"), arg),
                                            b(str("bandwidth-based-metrics"),
                                                c(
                                                    b(a(str("bandwidth"), arg),
                                                        sc(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                      (str("disable")),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("spf") | str("error") | str("event") | str("packet-dump") | str("flooding") | str("lsa-analysis") | str("packets") | str("hello") | str("database-description") | str("lsa-request") | str("lsa-update") | str("lsa-ack") | str("ldp-synchronization") | str("on-demand") | str("nsr-synchronization") | str("graceful-restart") | str("restart-signaling") | str("backup-spf") | str("source-packet-routing") | str("post-convergence-lfa") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("spf-options"),
                        c(
                            a(str("delay"), arg),
                            a(str("holddown"), arg),
                            a(str("rapid-runs"), arg),
                            str("no-ignore-our-externals")
                        )
                    ),
                    a(str("prefix-export-limit"), arg),
                    b(str("rib-groups"),
                        c(
                            a(str("inet"), arg),
                            a(str("inet3"), arg)
                        )
                    ),
                    str("job-stats"),
                    b(str("overload"),
                        c(
                            a(str("timeout"), arg),
                            str("allow-route-leaking"),
                            str("stub-network"),
                            str("intra-area-prefix"),
                            str("as-external")
                        )
                    ),
                    b(str("database-protection"),
                        c(
                            a(str("maximum-lsa"), arg),
                            str("warning-only"),
                            a(str("warning-threshold"), arg),
                            a(str("ignore-count"), arg),
                            a(str("ignore-time"), arg),
                            a(str("reset-time"), arg)
                        )
                    ),
                    b(str("graceful-restart"),
                        c(
                              (str("disable")),
                            a(str("restart-duration"), arg),
                            a(str("notify-duration"), arg),
                            b(str("helper-disable"),
                                c(
                                    c(
                                      str("standard"),
                                      str("restart-signaling"),
                                      str("both")
                                    )
                                )
                            ),
                            str("no-strict-lsa-checking")
                        )
                    ),
                    b(str("route-type-community"),
                      (str("iana") | str("vendor"))
                    ),
                    b(str("domain-id"),
                        sc(
                            ca(
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    c(
                      a(str("domain-vpn-tag"), arg),
                      str("no-domain-vpn-tag")
                    ),
                    a(str("preference"), arg),
                    a(str("external-preference"), arg),
                    a(str("labeled-preference"), arg),
                    b(str("export"),
                      policy_algebra
                    ),
                    b(str("import"),
                      policy_algebra
                    ),
                    a(str("reference-bandwidth"), arg),
                    a(str("lsa-refresh-interval"), arg),
                    a(str("spf-delay"), arg),
                    str("no-rfc-1583"),
                    str("forwarding-address-to-broadcast"),
                    c(
                      str("no-nssa-abr")
                    ),
                    b(str("sham-link"),
                        c(
                            b(str("local"),
                              ipaddr
                            ),
                            str("no-advertise-local")
                        )
                    )
                )
            ),
            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                c(
                    str("disable"),
                    a(str("topology-id"), arg),
                    str("overload"),
                    a(str("rib-group"), arg),
                    b(str("spf-options"),
                        c(
                            a(str("delay"), arg),
                            a(str("holddown"), arg),
                            a(str("rapid-runs"), arg),
                            str("no-ignore-our-externals")
                        )
                    ),
                    b(str("backup-spf-options"),
                        c(
                            b(str("remote-backup-calculation"),
                                c(
                                    b(str("pq-nodes-nearest-to-source"),
                                        c(
                                            a(str("percent"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("use-post-convergence-lfa"),
                                c(
                                    a(str("maximum-labels"), arg),
                                    a(str("maximum-backup-paths"), arg)
                                )
                            ),
                            str("use-source-packet-routing"),
                            str("disable"),
                            str("no-install"),
                            str("downstream-paths-only"),
                            b(str("per-prefix-calculation"),
                                c(
                                    str("stubs"),
                                    str("summary"),
                                    str("externals"),
                                    str("all")
                                )
                            ),
                            str("node-link-degradation")
                        )
                    ),
                    a(str("prefix-export-limit"), arg)
                )
            ),
            b(str("backup-spf-options"),
                c(
                    b(str("remote-backup-calculation"),
                        c(
                            b(str("pq-nodes-nearest-to-source"),
                                c(
                                    a(str("percent"), arg)
                                )
                            )
                        )
                    ),
                    b(str("use-post-convergence-lfa"),
                        c(
                            a(str("maximum-labels"), arg),
                            a(str("maximum-backup-paths"), arg)
                        )
                    ),
                    str("use-source-packet-routing"),
                    str("disable"),
                    str("no-install"),
                    str("downstream-paths-only"),
                    b(str("per-prefix-calculation"),
                        c(
                            str("stubs"),
                            str("summary"),
                            str("externals"),
                            str("all")
                        )
                    ),
                    str("node-link-degradation")
                )
            ),
            b(str("traffic-engineering"),
                c(
                    str("no-topology"),
                    str("multicast-rpf-routes"),
                    str("igp-topology"),
                    str("ignore-lsp-metrics"),
                    b(str("shortcuts"),
                        c(
                            str("ignore-lsp-metrics"),
                            str("lsp-metric-into-summary"),
                            a(str("family"), enum(str("inet") | str("inet-mpls")))
                        )
                    ),
                    str("advertise-unnumbered-interfaces"),
                    str("credibility-protocol-preference"),
                    b(str("advertisement"),
                        c(
                            str("always")
                        )
                    )
                )
            ),
            b(str("source-packet-routing"),
                c(
                    b(str("adjacency-segment"),
                        c(
                            a(str("hold-time"), arg)
                        )
                    ),
                    b(str("prefix-segment"),
                      policy_algebra
                    ),
                    str("explicit-null"),
                    b(str("node-segment"),
                        c(
                            a(str("ipv4-index"), arg),
                            a(str("index-range"), arg)
                        )
                    ),
                    b(str("srgb"),
                        sc(
                            a(str("start-label"), arg),
                            a(str("index-range"), arg)
                        )
                    ).as(:oneline),
                    a(str("mapping-server"), arg),
                    str("install-prefix-sid-for-best-route"),
                    str("ldp-stitching")
                )
            ),
            b(a(str("area"), arg),
                c(
                    c(
                      b(str("stub"),
                          sc(
                              a(str("default-metric"), arg),
                              str("summaries"),
                              str("no-summaries")
                          )
                      ).as(:oneline),
                      b(str("nssa"),
                          c(
                              b(str("default-lsa"),
                                  c(
                                      a(str("default-metric"), arg),
                                      a(str("metric-type"), arg),
                                      str("type-7")
                                  )
                              ),
                              a(str("default-metric"), arg),
                              a(str("metric-type"), arg),
                              str("summaries"),
                              str("no-summaries"),
                              b(a(str("area-range"), arg),
                                  c(
                                      str("restrict"),
                                      str("exact"),
                                      b(str("override-metric"),
                                          ca(
                                              a(str("metric-type"), arg)
                                          )
                                      )
                                  )
                              )
                          )
                      )
                    ),
                    b(a(str("area-range"), arg),
                        c(
                            str("restrict"),
                            str("exact"),
                            a(str("override-metric"), arg)
                        )
                    ),
                    b(str("network-summary-export"),
                      policy_algebra
                    ),
                    b(str("network-summary-import"),
                      policy_algebra
                    ),
                    b(str("inter-area-prefix-export"),
                      policy_algebra
                    ),
                    b(str("inter-area-prefix-import"),
                      policy_algebra
                    ),
                    b(str("authentication-type"),
                      (str("none") | str("simple") | str("md5"))
                    ),
                    b(str("virtual-link"),
                        s(
                          a(str("neighbor-id"), arg),
                          a(str("transit-area"), arg),
                          c(
                              (str("disable")),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            a(str("mtu"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              ),
                              b(str("authentication-key"),
                                  sc(
                                        unreadable,
                                      a(str("key-id"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            str("no-neighbor-down-notification"),
                            a(str("ipsec-sa"), arg),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                          )
                        )
                    ),
                    b(a(str("sham-link-remote"), arg),
                        c(
                            a(str("metric"), arg),
                            a(str("ipsec-sa"), arg),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("interface"), arg),
                        c(
                              (str("disable")),
                            b(str("interface-type"),
                              (str("nbma") | str("p2mp") | str("p2p") | str("p2mp-over-lan"))
                            ),
                            c(
                              str("link-protection"),
                              str("node-link-protection")
                            ),
                            str("no-eligible-backup"),
                            str("no-eligible-remote-backup"),
                            b(str("passive"),
                                c(
                                    b(str("traffic-engineering"),
                                        c(
                                            b(str("remote-node-id"),
                                              ipaddr
                                            ),
                                            b(str("remote-node-router-id"),
                                              ipv4addr
                                            )
                                        )
                                    )
                                )
                            ),
                            str("secondary"),
                            str("own-router-lsa"),
                            b(str("bandwidth-based-metrics"),
                                c(
                                    b(a(str("bandwidth"), arg),
                                        sc(
                                            a(str("metric"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            a(str("metric"), arg),
                            a(str("priority"), arg),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            a(str("mtu"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              ),
                              b(str("authentication-key"),
                                  sc(
                                        unreadable,
                                      a(str("key-id"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            str("no-neighbor-down-notification"),
                            a(str("ipsec-sa"), arg),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            a(str("transmit-interval"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("authentication"),
                                        c(
                                            a(str("key-chain"), arg),
                                            b(str("algorithm"),
                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                            ),
                                            str("loose-check")
                                        )
                                    ),
                                    str("full-neighbors-only")
                                )
                            ),
                            str("dynamic-neighbors"),
                            str("no-advertise-adjacency-segment"),
                            b(a(str("neighbor"), arg),
                                sc(
                                    str("eligible")
                                )
                            ).as(:oneline),
                            a(str("poll-interval"), arg),
                            str("no-interface-state-traps"),
                            b(str("post-convergence-lfa"),
                                c(
                                    b(str("node-protection"),
                                        c(
                                            a(str("cost"), arg)
                                        )
                                    )
                                )
                            ),
                            a(str("te-metric"), arg),
                            b(str("ldp-synchronization"),
                              ldp_sync_obj
                            ),
                            b(str("ipv4-adjacency-segment"),
                                c(
                                    b(str("protected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("unprotected"),
                                        sc(
                                            c(
                                              b(str("index"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline),
                                              a(str("label"), arg),
                                              str("dynamic")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(a(str("lan-neighbor"), arg),
                                c(
                                    b(str("ipv4-adjacency-segment"),
                                        c(
                                            b(str("protected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("unprotected"),
                                                sc(
                                                    c(
                                                      b(str("index"),
                                                          sc(
                                                                arg
                                                          )
                                                      ).as(:oneline),
                                                      a(str("label"), arg),
                                                      str("dynamic")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("no-context-identifier-advertisement"),
                    b(a(str("peer-interface"), arg),
                        c(
                              (str("disable")),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            a(str("mtu"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              ),
                              b(str("authentication-key"),
                                  sc(
                                        unreadable,
                                      a(str("key-id"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            str("no-neighbor-down-notification")
                        )
                    ),
                    str("no-source-packet-routing"),
                    a(str("context-identifier"), arg),
                    b(a(str("label-switched-path"), arg),
                        c(
                              (str("disable")),
                            a(str("metric"), arg),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("metric"), arg),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                sc(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
              (str("disable")),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("spf") | str("error") | str("event") | str("packet-dump") | str("flooding") | str("lsa-analysis") | str("packets") | str("hello") | str("database-description") | str("lsa-request") | str("lsa-update") | str("lsa-ack") | str("ldp-synchronization") | str("on-demand") | str("nsr-synchronization") | str("graceful-restart") | str("restart-signaling") | str("backup-spf") | str("source-packet-routing") | str("post-convergence-lfa") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("spf-options"),
                c(
                    a(str("delay"), arg),
                    a(str("holddown"), arg),
                    a(str("rapid-runs"), arg),
                    str("no-ignore-our-externals")
                )
            ),
            a(str("prefix-export-limit"), arg),
            b(str("rib-groups"),
                c(
                    a(str("inet"), arg),
                    a(str("inet3"), arg)
                )
            ),
            str("job-stats"),
            b(str("overload"),
                c(
                    a(str("timeout"), arg),
                    str("allow-route-leaking"),
                    str("stub-network"),
                    str("intra-area-prefix"),
                    str("as-external")
                )
            ),
            b(str("database-protection"),
                c(
                    a(str("maximum-lsa"), arg),
                    str("warning-only"),
                    a(str("warning-threshold"), arg),
                    a(str("ignore-count"), arg),
                    a(str("ignore-time"), arg),
                    a(str("reset-time"), arg)
                )
            ),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-duration"), arg),
                    a(str("notify-duration"), arg),
                    b(str("helper-disable"),
                        c(
                            c(
                              str("standard"),
                              str("restart-signaling"),
                              str("both")
                            )
                        )
                    ),
                    str("no-strict-lsa-checking")
                )
            ),
            b(str("route-type-community"),
              (str("iana") | str("vendor"))
            ),
            b(str("domain-id"),
                sc(
                    ca(
                      str("disable")
                    )
                )
            ).as(:oneline),
            c(
              a(str("domain-vpn-tag"), arg),
              str("no-domain-vpn-tag")
            ),
            a(str("preference"), arg),
            a(str("external-preference"), arg),
            a(str("labeled-preference"), arg),
            b(str("export"),
              policy_algebra
            ),
            b(str("import"),
              policy_algebra
            ),
            a(str("reference-bandwidth"), arg),
            a(str("lsa-refresh-interval"), arg),
            a(str("spf-delay"), arg),
            str("no-rfc-1583"),
            str("forwarding-address-to-broadcast"),
            c(
              str("no-nssa-abr")
            ),
            b(str("sham-link"),
                c(
                    b(str("local"),
                      ipaddr
                    ),
                    str("no-advertise-local")
                )
            )
        )
    end

    rule(:juniper_protocols_overlayd) do
        c(
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("socket") | str("rtsock") | str("config") | str("all"))).as(:oneline)
                )
            )
        )
    end

    rule(:juniper_protocols_pgm) do
        c(
            b(str("traceoptions"),
                c(
                    a(str("flag"), enum(str("init") | str("show") | str("route-socket") | str("parse") | str("state") | str("packets") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            )
        )
    end

    rule(:juniper_protocols_pim) do
        c(
            b(str("family"),
                c(
                    b(str("any"),
                        c(
                            str("disable")
                        )
                    ),
                    b(str("inet"),
                        c(
                              (str("disable"))
                        )
                    ),
                    b(str("inet6"),
                        c(
                              (str("disable"))
                        )
                    )
                )
            ),
              (str("disable")),
            b(str("nonstop-routing"),
                c(
                      (str("disable"))
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("route") | str("packets") | str("hello") | str("register") | str("join") | str("prune") | str("graft") | str("bootstrap") | str("rp") | str("autorp") | str("assert") | str("mdt") | str("nsr-synchronization") | str("bidirectional-df-election") | str("mofrr") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable"),
                            b(str("filter"),
                              pim_filter_obj
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("dense-groups"),
                c(
                    str("dynamic-reject"),
                        sc(
                              (str("reject") | str("announce"))
                        ).as(:oneline)
                )
            ),
            b(str("vpn-tunnel-source"),
              ipv4addr
            ),
            b(str("vpn-group-address"),
              ipv4addr
            ),
            b(str("tunnel-devices"),
              interface_device
            ),
            b(str("rpf-selection"),
                c(
                    b(a(str("group"), arg),
                        c(
                            b(str("wildcard-source"),
                                c(
                                    b(str("next-hop"),
                                      ipaddr
                                    )
                                )
                            ),
                            b(a(str("source"), arg),
                                c(
                                    b(str("next-hop"),
                                      ipaddr
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("prefix-list"), arg),
                        c(
                            b(str("wildcard-source"),
                                c(
                                    b(str("next-hop"),
                                      ipaddr
                                    )
                                )
                            ),
                            b(a(str("source"), arg),
                                c(
                                    b(str("next-hop"),
                                      ipaddr
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("mvpn"),
                c(
                    b(str("autodiscovery"),
                        c(
                            str("inet-mdt")
                        )
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    str("rosen-mvpn"),
                                    str("ngen-mvpn"),
                                    b(str("autodiscovery"),
                                        c(
                                            str("inet-mdt")
                                        )
                                    ),
                                    str("disable")
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    str("rosen-mvpn"),
                                    str("ngen-mvpn"),
                                    b(str("autodiscovery"),
                                        c(
                                            str("inet-mdt")
                                        )
                                    ),
                                    str("disable")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("rib-group"),
              rib_group_type
            ),
            b(str("import"),
              policy_algebra
            ),
            b(str("export"),
              policy_algebra
            ),
            b(str("mldp-inband-signalling"),
                c(
                    b(str("policy"),
                      policy_algebra
                    )
                )
            ),
            b(str("rpf-vector"),
                c(
                    b(str("policy"),
                      policy_algebra
                    )
                )
            ),
            a(str("assert-timeout"), arg),
            a(str("assert-robust-count"), arg),
            a(str("join-prune-timeout"), arg),
            b(str("spt-threshold"),
                c(
                    b(str("infinity"),
                      policy_algebra
                    )
                )
            ),
            b(str("sglimit"),
                c(
                    a(str("family"), enum(str("inet6") | str("inet")),
                        c(
                            a(str("maximum"), arg),
                            a(str("threshold"), arg),
                            a(str("log-interval"), arg)
                        )
                    ),
                    a(str("maximum"), arg),
                    a(str("threshold"), arg),
                    a(str("log-interval"), arg)
                )
            ),
            b(str("rp"),
                c(
                    a(str("bootstrap-priority"), arg),
                    b(str("bootstrap-import"),
                      policy_algebra
                    ),
                    b(str("bootstrap-export"),
                      policy_algebra
                    ),
                    b(str("bootstrap"),
                        c(
                            b(str("family"),
                                c(
                                    b(str("inet"),
                                      pim_bootstrap_options_type
                                    ),
                                    b(str("inet6"),
                                      pim_bootstrap_options_type
                                    )
                                )
                            )
                        )
                    ),
                    b(str("register-limit"),
                        c(
                            a(str("family"), enum(str("inet6") | str("inet")),
                                c(
                                    a(str("maximum"), arg),
                                    a(str("threshold"), arg),
                                    a(str("log-interval"), arg)
                                )
                            ),
                            a(str("maximum"), arg),
                            a(str("threshold"), arg),
                            a(str("log-interval"), arg)
                        )
                    ),
                    b(str("group-rp-mapping"),
                        c(
                            a(str("family"), enum(str("inet6") | str("inet")),
                                c(
                                    a(str("maximum"), arg),
                                    a(str("threshold"), arg),
                                    a(str("log-interval"), arg)
                                )
                            ),
                            a(str("maximum"), arg),
                            a(str("threshold"), arg),
                            a(str("log-interval"), arg)
                        )
                    ),
                    b(str("rp-register-policy"),
                      policy_algebra
                    ),
                    b(str("dr-register-policy"),
                      policy_algebra
                    ),
                    b(str("local"),
                        c(
                            b(str("address"),
                              ipv4addr
                            ),
                              (str("disable")),
                            a(str("priority"), arg),
                            a(str("hold-time"), arg),
                            a(str("group-ranges"), arg),
                            str("override"),
                            str("process-non-null-as-null-register"),
                            b(str("family"),
                                c(
                                    b(str("inet"),
                                        c(
                                            b(str("address"),
                                              ipv4addr
                                            ),
                                              (str("disable")),
                                            a(str("priority"), arg),
                                            a(str("hold-time"), arg),
                                            a(str("group-ranges"), arg),
                                            str("override"),
                                            b(str("anycast-pim"),
                                                c(
                                                    b(str("rp-set"),
                                                        c(
                                                            b(a(str("address"), arg),
                                                                c(
                                                                    str("forward-msdp-sa")
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("local-address"),
                                                      ipaddr
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("inet6"),
                                        c(
                                            b(str("address"),
                                              ipv6addr
                                            ),
                                              (str("disable")),
                                            a(str("priority"), arg),
                                            a(str("hold-time"), arg),
                                            a(str("group-ranges"), arg),
                                            str("override"),
                                            b(str("anycast-pim"),
                                                c(
                                                    b(str("rp-set"),
                                                        c(
                                                            a(str("address"), arg)
                                                        )
                                                    ),
                                                    b(str("local-address"),
                                                      ipv6addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("embedded-rp"),
                        c(
                            b(str("group-ranges"),
                              pim_rp_group_range_type
                            ),
                            a(str("maximum-rps"), arg)
                        )
                    ),
                    b(str("auto-rp"),
                        c(
                              (str("discovery") | str("announce") | str("mapping")),
                            str("mapping-agent-election"),
                            str("no-mapping-agent-election")
                        )
                    ),
                    b(str("static"),
                        c(
                            b(a(str("address"), arg),
                                c(
                                    a(str("version"), arg),
                                    b(str("group-ranges"),
                                      pim_rp_group_range_type
                                    ),
                                    str("override")
                                )
                            )
                        )
                    ),
                    b(str("bidirectional"),
                        c(
                            b(a(str("address"), arg),
                                c(
                                    a(str("priority"), arg),
                                    a(str("hold-time"), arg),
                                    b(str("group-ranges"),
                                      pim_rp_group_range_type
                                    )
                                )
                            )
                        )
                    ),
                    a(str("register-probe-time"), arg)
                )
            ),
            str("passive"),
            a(str("interface"), arg | arg,
                c(
                    b(str("family"),
                        c(
                            b(str("any"),
                                c(
                                    str("disable")
                                )
                            ),
                            b(str("inet"),
                                c(
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("version"),
                                              (str("0") | str("1") | str("automatic"))
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("minimum-transmit-interval"), arg),
                                            a(str("minimum-receive-interval"), arg),
                                            a(str("multiplier"), arg),
                                            c(
                                              str("no-adaptation")
                                            ),
                                            b(str("transmit-interval"),
                                                c(
                                                    a(str("minimum-interval"), arg),
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("detection-time"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("authentication"),
                                                c(
                                                    a(str("key-chain"), arg),
                                                    b(str("algorithm"),
                                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                    ),
                                                    str("loose-check")
                                                )
                                            )
                                        )
                                    ),
                                    str("mcae-mac-synchronize"),
                                      (str("disable"))
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("version"),
                                              (str("0") | str("1") | str("automatic"))
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("minimum-transmit-interval"), arg),
                                            a(str("minimum-receive-interval"), arg),
                                            a(str("multiplier"), arg),
                                            c(
                                              str("no-adaptation")
                                            ),
                                            b(str("transmit-interval"),
                                                c(
                                                    a(str("minimum-interval"), arg),
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("detection-time"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("authentication"),
                                                c(
                                                    a(str("key-chain"), arg),
                                                    b(str("algorithm"),
                                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                    ),
                                                    str("loose-check")
                                                )
                                            )
                                        )
                                    ),
                                      (str("disable"))
                                )
                            )
                        )
                    ),
                      (str("disable")),
                    b(str("bidirectional"),
                        c(
                            b(str("df-election"),
                                c(
                                    a(str("robustness-count"), arg),
                                    a(str("offer-period"), arg),
                                    a(str("backoff-period"), arg)
                                )
                            )
                        )
                    ),
                    b(str("mode"),
                      (str("dense") | str("sparse") | str("sparse-dense") | str("bidirectional-sparse") | str("bidirectional-sparse-dense"))
                    ),
                    a(str("priority"), arg),
                    str("stickydr"),
                    b(str("multiple-triggered-joins"),
                        c(
                            a(str("count"), arg),
                            a(str("interval"), arg)
                        )
                    ),
                    a(str("version"), arg),
                    a(str("hello-interval"), arg),
                    b(str("neighbor-policy"),
                      policy_algebra
                    ),
                    b(str("accept-join-always-from"),
                      policy_algebra
                    ),
                    str("accept-remote-source"),
                    b(str("dual-dr"),
                        c(
                            str("enhanced")
                        )
                    ),
                    str("distributed-dr"),
                    str("reset-tracking-bit"),
                    a(str("propagation-delay"), arg),
                    a(str("override-interval"), arg),
                    b(str("bfd-liveness-detection"),
                        c(
                            b(str("version"),
                              (str("0") | str("1") | str("automatic"))
                            ),
                            a(str("minimum-interval"), arg),
                            a(str("minimum-transmit-interval"), arg),
                            a(str("minimum-receive-interval"), arg),
                            a(str("multiplier"), arg),
                            c(
                              str("no-adaptation")
                            ),
                            b(str("transmit-interval"),
                                c(
                                    a(str("minimum-interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("detection-time"),
                                c(
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("authentication"),
                                c(
                                    a(str("key-chain"), arg),
                                    b(str("algorithm"),
                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                    ),
                                    str("loose-check")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("mdt"),
                c(
                    b(str("threshold"),
                        c(
                            b(a(str("group"), arg),
                                c(
                                    b(a(str("source"), arg),
                                        c(
                                            a(str("rate"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("data-mdt-reuse"),
                    a(str("tunnel-limit"), arg),
                    b(str("group-range"),
                      ipprefix
                    )
                )
            ),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-duration"), arg),
                    str("no-bidirectional-mode"),
                    a(str("restart-complete-duration"), arg)
                )
            ),
            b(str("join-load-balance"),
                c(
                    str("automatic")
                )
            ),
            a(str("standby-path-creation-delay"), arg),
            a(str("idle-standby-path-switchover-delay"), arg),
            str("dr-election-on-p2p"),
            str("no-wildcard-register-stop"),
            a(str("nexthop-hold-time"), arg),
            str("mpls-internet-multicast"),
            b(str("join-make-before-break"),
                c(
                      (str("disable"))
                )
            ),
            str("reset-tracking-bit"),
            a(str("propagation-delay"), arg),
            a(str("override-interval"), arg),
            b(str("default-vpn-source"),
                c(
                    b(str("interface-name"),
                      interface_unit
                    )
                )
            ),
            b(str("static"),
                c(
                    str("distributed"),
                    b(a(str("group"), arg),
                        c(
                            str("distributed"),
                            b(a(str("source"), arg),
                                c(
                                    str("distributed"),
                                    str("no-upstream-join")
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_protection_group) do
        c(
            b(str("ethernet-aps"),
              juniper_protocols_protection_group_eaps
            ),
            b(str("traceoptions"),
              erp_trace_options
            ),
            a(str("restore-interval"), arg),
            a(str("guard-interval"), arg),
            a(str("hold-interval"), arg),
            b(str("ethernet-ring"),
              juniper_protocols_protection_group_ethernet_ring
            )
        )
    end

    rule(:erp_trace_options) do
        c(
            a(str("flag"), enum(str("events") | str("pdu") | str("timers") | str("state-machine") | str("periodic-packet-management") | str("config") | str("normal") | str("debug") | str("all"))).as(:oneline),
            b(str("file"),
                sc(
                      arg,
                    str("replace"),
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("no-stamp"),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline)
        )
    end

    rule(:juniper_protocols_protection_group_eaps) do
        c(
              juniper_protocols_protection_group_eaps_profile
        )
    end

    rule(:juniper_protocols_protection_group_eaps_profile) do
      b(arg.as(:arg),
        c(
            b(str("protocol"),
              (str("ccm") | str("G.8031"))
            ),
            a(str("revert-time"), arg),
            a(str("hold-time"), arg),
            b(str("local-request"),
              (str("lockout"))
            )
        )
      )
    end

    rule(:juniper_protocols_protection_group_ethernet_ring) do
      b(arg.as(:arg),
        c(
            b(str("node-id"),
              mac_unicast
            ),
            str("ring-protection-link-owner"),
            a(str("level"), arg),
            a(str("restore-interval"), arg),
            a(str("guard-interval"), arg),
            a(str("hold-interval"), arg),
            str("non-revertive"),
            a(str("wait-to-block-interval"), arg),
            a(str("major-ring-name"), arg),
            str("propagate-tc"),
            a(str("compatibility-version"), arg),
            a(str("ring-id"), arg),
            str("non-vc-mode"),
            a(str("dot1p-priority"), arg),
            b(str("east-interface"),
              erp_interface
            ),
            b(str("west-interface"),
              erp_interface
            ),
            a(str("control-vlan"), arg),
            b(str("data-channel"),
              erp_data_channel
            )
        )
      )
    end

    rule(:erp_data_channel) do
        c(
            a(str("vlan"), arg)
        )
    end

    rule(:erp_interface) do
        c(
            b(str("control-channel"),
                c(
                    a(str("vlan"), arg),
                      interface_name
                )
            ),
            str("ring-protection-link-end"),
            str("interface-none")
        )
    end

    rule(:juniper_protocols_rip) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("auth") | str("error") | str("expiration") | str("holddown") | str("packets") | str("request") | str("trigger") | str("update") | str("nsr-synchronization") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable"),
                            b(str("filter"),
                              rip_filter_obj
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            a(str("metric-in"), arg),
            b(str("send"),
                sc(
                    c(
                      str("broadcast"),
                      str("multicast"),
                      str("none"),
                      str("version-1")
                    )
                )
            ).as(:oneline),
            b(str("receive"),
                sc(
                    c(
                      str("both"),
                      str("none"),
                      str("version-1"),
                      str("version-2")
                    )
                )
            ).as(:oneline),
            str("check-zero"),
            str("no-check-zero"),
            a(str("message-size"), arg),
            b(str("import"),
              policy_algebra
            ),
            a(str("holddown"), arg),
            a(str("route-timeout"), arg),
            a(str("update-interval"), arg),
            b(str("authentication-type"),
              (str("none") | str("simple") | str("md5"))
            ),
            b(str("authentication-key"),
              unreadable
            ),
            b(a(str("group"), arg),
                c(
                    a(str("route-timeout"), arg),
                    a(str("update-interval"), arg),
                    a(str("preference"), arg),
                    a(str("metric-out"), arg),
                    b(str("export"),
                      policy_algebra
                    ),
                    b(str("import"),
                      policy_algebra
                    ),
                    str("demand-circuit"),
                    a(str("max-retrans-time"), arg),
                    b(str("bfd-liveness-detection"),
                        c(
                            b(str("version"),
                              (str("0") | str("1") | str("automatic"))
                            ),
                            a(str("minimum-interval"), arg),
                            a(str("minimum-transmit-interval"), arg),
                            a(str("minimum-receive-interval"), arg),
                            a(str("multiplier"), arg),
                            c(
                              str("no-adaptation")
                            ),
                            b(str("transmit-interval"),
                                c(
                                    a(str("minimum-interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("detection-time"),
                                c(
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("authentication"),
                                c(
                                    a(str("key-chain"), arg),
                                    b(str("algorithm"),
                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                    ),
                                    str("loose-check")
                                )
                            )
                        )
                    ),
                    b(a(str("neighbor"), arg),
                        c(
                            a(str("route-timeout"), arg),
                            a(str("update-interval"), arg),
                            b(str("interface-type"),
                              (str("p2mp"))
                            ),
                            str("dynamic-peers"),
                            a(str("peer"), arg).as(:oneline),
                            a(str("metric-in"), arg),
                            b(str("send"),
                                sc(
                                    c(
                                      str("broadcast"),
                                      str("multicast"),
                                      str("none"),
                                      str("version-1")
                                    )
                                )
                            ).as(:oneline),
                            b(str("receive"),
                                sc(
                                    c(
                                      str("both"),
                                      str("none"),
                                      str("version-1"),
                                      str("version-2")
                                    )
                                )
                            ).as(:oneline),
                            str("demand-circuit"),
                            a(str("max-retrans-time"), arg),
                            str("check-zero"),
                            str("no-check-zero"),
                            str("any-sender"),
                            a(str("message-size"), arg),
                            b(str("import"),
                              policy_algebra
                            ),
                            b(str("authentication-type"),
                              (str("none") | str("simple") | str("md5"))
                            ),
                            b(str("authentication-key"),
                              unreadable
                            ),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("authentication"),
                                        c(
                                            a(str("key-chain"), arg),
                                            b(str("algorithm"),
                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                            ),
                                            str("loose-check")
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-time"), arg)
                )
            )
        )
    end

    rule(:juniper_protocols_ripng) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("error") | str("expiration") | str("holddown") | str("packets") | str("request") | str("trigger") | str("update") | str("nsr-synchronization") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("metric-in"), arg),
            b(str("send"),
                sc(
                    c(
                      str("none")
                    )
                )
            ).as(:oneline),
            b(str("receive"),
                sc(
                    c(
                      str("none")
                    )
                )
            ).as(:oneline),
            b(str("import"),
              policy_algebra
            ),
            a(str("holddown"), arg),
            a(str("route-timeout"), arg),
            a(str("update-interval"), arg),
            b(a(str("group"), arg),
                c(
                    a(str("route-timeout"), arg),
                    a(str("update-interval"), arg),
                    a(str("preference"), arg),
                    a(str("metric-out"), arg),
                    b(str("export"),
                      policy_algebra
                    ),
                    b(str("import"),
                      policy_algebra
                    ),
                    b(a(str("neighbor"), arg),
                        c(
                            a(str("route-timeout"), arg),
                            a(str("update-interval"), arg),
                            a(str("metric-in"), arg),
                            b(str("send"),
                                sc(
                                    c(
                                      str("none")
                                    )
                                )
                            ).as(:oneline),
                            b(str("receive"),
                                sc(
                                    c(
                                      str("none")
                                    )
                                )
                            ).as(:oneline),
                            b(str("import"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-time"), arg)
                )
            )
        )
    end

    rule(:juniper_protocols_router_discovery) do
        c(
              (str("disable")),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"))).as(:oneline)
                )
            ),
            b(a(str("interface"), arg),
                c(
                    a(str("max-advertisement-interval"), arg),
                    a(str("min-advertisement-interval"), arg),
                    a(str("lifetime"), arg)
                )
            ),
            b(a(str("address"), arg),
                c(
                    str("advertise"),
                    str("ignore"),
                    str("broadcast"),
                    str("multicast"),
                    str("ineligible"),
                    a(str("priority"), arg)
                )
            )
        )
    end

    rule(:juniper_protocols_rsvp) do
        c(
              (str("disable")),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    str("helper-disable"),
                    a(str("maximum-helper-restart-time"), arg),
                    a(str("maximum-helper-recovery-time"), arg)
                )
            ),
            b(str("tunnel-services"),
                c(
                    b(str("devices"),
                      interface_device
                    )
                )
            ),
            str("no-p2mp-sublsp"),
            str("no-node-id-subobject"),
            str("no-interface-hello"),
            b(str("pop-and-forward"),
                c(
                    b(str("application-label"),
                        c(
                            a(str("depth"), arg)
                        )
                    )
                )
            ),
            str("hello-acknowledgements"),
            str("no-hello-acknowledgements"),
            b(str("node-hello"),
                sc(
                    a(str("hello-interval"), arg)
                )
            ).as(:oneline),
            str("no-node-hello"),
            str("allow-bidirectional"),
            str("local-reversion"),
            str("no-local-reversion"),
            b(str("fast-reroute"),
                c(
                    a(str("optimize-timer"), arg)
                )
            ),
            b(str("load-balance"),
                c(
                    str("bandwidth")
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("io-event") | str("io-packets") | str("packets") | str("path") | str("resv") | str("pathtear") | str("resvtear") | str("state") | str("error") | str("route") | str("lmp") | str("event") | str("nsr-synchronization") | str("lsp-prefix") | str("enhanced-frr") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("refresh-time"), arg),
            a(str("keep-multiplier"), arg),
            a(str("graceful-deletion-timeout"), arg),
            str("setup-protection"),
            str("cross-credibility-cspf"),
            b(str("preemption"),
                c(
                    c(
                      str("disabled"),
                      str("normal"),
                      str("aggressive")
                    ),
                    b(str("soft-preemption"),
                        c(
                            a(str("cleanup-timer"), arg)
                        )
                    )
                )
            ),
            b(str("authentication-key"),
              unreadable
            ),
            str("no-authentication-check"),
            b(str("associated-bidirectional-lsp"),
                c(
                    str("single-sided-provisioning")
                )
            ),
            str("no-enhanced-frr-bypass"),
            b(a(str("interface"), arg),
                c(
                      (str("disable")),
                    b(str("authentication-key"),
                      unreadable
                    ),
                    str("aggregate"),
                    str("no-aggregate"),
                    str("reliable"),
                    str("no-reliable"),
                    a(str("hello-interval"), arg),
                    b(str("subscription"),
                      subscription_type
                    ),
                    a(str("bandwidth"), arg),
                    b(str("update-threshold"),
                        ca(
                            a(str("threshold-value"), arg)
                        )
                    ),
                    b(str("update-threshold-max-reservable"),
                        ca(
                            a(str("percent"), arg)
                        )
                    ),
                    b(str("link-protection"),
                        c(
                              (str("disable")),
                            b(str("bandwidth"),
                              bandwidth_type
                            ),
                            a(str("max-bypasses"), arg),
                            a(str("subscription"), arg),
                            str("no-node-protection"),
                            a(str("optimize-timer"), arg),
                            a(str("class-of-service"), arg),
                            a(str("hop-limit"), arg),
                            str("no-cspf"),
                            str("exclude-srlg"),
        b(str("priority"),
          a(arg, arg)
                                
                            ),
                            b(a(str("path"), arg),
                                sc(
                                    c(
                                      str("loose"),
                                      str("strict")
                                    )
                                )
                            ).as(:oneline),
                            b(str("admin-group"),
                              admin_group_include_exclude
                            ),
                            b(a(str("bypass"), arg),
                                c(
                                    b(str("to"),
                                      ipv4addr
                                    ),
                                    b(str("bandwidth"),
                                      bandwidth_type
                                    ),
                                    b(str("subscription"),
                                      bypass_subscription_type
                                    ),
                                    a(str("description"), quote | arg),
        b(str("priority"),
          a(arg, arg)
                                        
                                    ),
                                    a(str("class-of-service"), arg),
                                    a(str("hop-limit"), arg),
                                    str("no-cspf"),
                                    str("exclude-srlg"),
                                    b(a(str("path"), arg),
                                        sc(
                                            c(
                                              str("loose"),
                                              str("strict")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("admin-group"),
                                      admin_group_include_exclude
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("peer-interface"), arg),
                c(
                      (str("disable")),
                    b(str("authentication-key"),
                      unreadable
                    ),
                    str("aggregate"),
                    str("no-aggregate"),
                    str("reliable"),
                    str("no-reliable"),
                    a(str("hello-interval"), arg),
                    b(str("dynamic-bidirectional-transport"),
                        c(
                            a(str("template"), arg)
                        )
                    )
                )
            ),
            b(a(str("lsp-set"), arg),
                c(
                      (str("disable")),
                    b(str("match-criteria"),
                      lsp_set_match_type
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("io-event") | str("io-packets") | str("packets") | str("path") | str("resv") | str("pathtear") | str("resvtear") | str("state") | str("error") | str("route") | str("lmp") | str("event") | str("nsr-synchronization") | str("lsp-prefix") | str("enhanced-frr") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
    end

    rule(:bypass_subscription_type) do
        c(
            arg
        )
    end

    rule(:juniper_protocols_stp) do
        c(
              (str("disable")),
            b(str("bpdu-destination-mac-address"),
              (str("provider-bridge-group"))
            ),
            a(str("bridge-priority"), arg),
            a(str("backup-bridge-priority"), arg),
            a(str("max-age"), arg),
            a(str("hello-time"), arg),
            a(str("forward-delay"), arg),
            b(str("system-identifier"),
              mac_unicast
            ),
            b(str("traceoptions"),
              stp_trace_options
            ),
            str("vpls-flush-on-topology-change"),
            a(str("priority-hold-time"), arg),
            b(str("system-id"),
              system_id_ip_map
            ),
            b(str("interface"),
              stp_interface
            ),
            a(str("extended-system-id"), arg),
            b(str("force-version"),
              (str("stp"))
            ),
            str("bpdu-block-on-edge")
        )
    end

    rule(:juniper_protocols_vgd) do
        c(
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            ),
                            str("microsecond-stamp")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("interface") | str("configuration") | str("core") | str("l2-client") | str("ovs-client") | str("function") | str("netconf-client") | str("all"))).as(:oneline)
                )
            ),
            a(str("interfaces"), arg),
            b(a(str("controller"), arg),
                c(
                    b(str("protocol"),
                        c(
                            b(str("tcp"),
                                c(
                                    a(str("port"), arg)
                                )
                            ),
                            b(str("ssl"),
                                c(
                                    a(str("port"), arg)
                                )
                            )
                        )
                    ),
                    a(str("maximum-backoff-duration"), arg),
                    a(str("inactivity-probe-duration"), arg)
                )
            ),
            str("copy-ovsdatabase-to-backup-ram")
        )
    end

    rule(:juniper_protocols_vni_options) do
        c(
            b(a(str("vni"), arg),
                c(
                    b(str("vrf-target"),
                        c(
                            a(str("export"), arg),
                            arg
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_vstp) do
        c(
              (str("disable")),
            b(str("force-version"),
              (str("stp"))
            ),
            str("bpdu-block-on-edge"),
            str("vpls-flush-on-topology-change"),
            a(str("priority-hold-time"), arg),
            b(str("system-id"),
              system_id_ip_map
            ),
            b(str("interface"),
              stp_interface
            ),
            a(str("vlan"), str("all") | arg,
                c(
                    a(str("bridge-priority"), arg),
                    a(str("backup-bridge-priority"), arg),
                    a(str("max-age"), arg),
                    a(str("hello-time"), arg),
                    a(str("forward-delay"), arg),
                    b(str("system-identifier"),
                      mac_unicast
                    ),
                    b(str("traceoptions"),
                      stp_trace_options
                    ),
                    b(str("interface"),
                      stp_interface
                    )
                )
            ),
            b(str("vlan-group"),
                c(
                    b(a(str("group"), arg),
                        c(
                            a(str("vlan"), arg),
                            a(str("bridge-priority"), arg),
                            a(str("backup-bridge-priority"), arg),
                            a(str("max-age"), arg),
                            a(str("hello-time"), arg),
                            a(str("forward-delay"), arg),
                            b(str("system-identifier"),
                              mac_unicast
                            ),
                            b(str("traceoptions"),
                              stp_trace_options
                            ),
                            b(str("interface"),
                              stp_interface
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_radius) do
        c(
            b(str("traceoptions"),
              radius_traceoptions
            ),
            b(str("servers"),
              juniper_radius_server
            ),
            b(str("clients"),
              juniper_radius_client
            ),
            b(str("network-elements"),
              juniper_radius_network_element
            ),
            b(str("network-element-groups"),
              juniper_radius_network_element_group
            ),
            b(str("snoop-segments"),
              juniper_radius_snoop_segment
            )
        )
    end

    rule(:juniper_radius_client) do
      b(arg.as(:arg),
        c(
            b(str("address"),
              ipv4prefix
            ),
            b(str("source-interface"),
                sc(
                      interface_name,
                    b(str("ipv4-address"),
                      ipv4addr
                    )
                )
            ).as(:oneline),
            str("prefer-framed-ip-address"),
            str("prefer-framed-ipv6-prefix"),
            b(str("accounting"),
                c(
                    a(str("secret"), arg),
                    a(str("response-cache-timeout"), arg),
                    a(str("port"), arg)
                )
            )
        )
      )
    end

    rule(:juniper_radius_network_element) do
      b(arg.as(:arg),
        c(
            b(a(str("server"), arg),
                sc(
                    a(str("priority"), arg)
                )
            ).as(:oneline),
            a(str("maximum-pending-reqs-limit"), arg),
            a(str("pending-queue-watermark"), arg),
            a(str("pending-queue-watermark-abate"), arg)
        )
      )
    end

    rule(:juniper_radius_network_element_group) do
      b(arg.as(:arg),
        c(
            b(a(str("network-element"), arg),
                sc(
                    str("mandatory")
                )
            ).as(:oneline),
            str("broadcast")
        )
      )
    end

    rule(:juniper_radius_server) do
      b(arg.as(:arg),
        c(
            b(str("address"),
              ipv4addr
            ),
            a(str("port"), arg),
            a(str("preauthentication-port"), arg),
            a(str("accounting-port"), arg),
            a(str("dynamic-request-port"), arg),
            a(str("secret"), arg),
            a(str("accounting-secret"), arg),
            str("allow-dynamic-requests"),
            a(str("dynamic-request-secret"), arg),
            a(str("timeout"), arg),
            a(str("retry"), arg),
            b(str("dead-criteria"),
                sc(
                    a(str("retries"), arg),
                    a(str("interval"), arg),
                    a(str("revert-interval"), arg)
                )
            ).as(:oneline),
            b(str("source-interface"),
                sc(
                      interface_name,
                    b(str("ipv4-address"),
                      ipv4addr
                    )
                )
            ).as(:oneline)
        )
      )
    end

    rule(:juniper_radius_snoop_segment) do
      b(arg.as(:arg),
        c(
            b(str("destination-ip-address"),
              ipv4addr
            ),
            b(str("source-ip-address"),
              ipv4addr
            ),
            a(str("destination-port"), arg),
            a(str("shared-secret"), arg),
            b(str("source-interface"),
                sc(
                      interface_name
                )
            ).as(:oneline),
            a(str("request-cache-timeout"), arg)
        )
      )
    end

    rule(:juniper_routing_instance) do
      b(arg.as(:arg),
        c(
            b(str("instance-type"),
              (str("forwarding") | str("no-forwarding") | str("l2vpn") | str("vpls") | str("virtual-switch") | str("l2backhaul-vpn") | str("virtual-router") | str("layer2-control") | str("mpls-internet-multicast") | str("evpn") | str("mpls-forwarding") | str("evpn-vpws") | str("vrf"))
            ),
            b(str("routing-options"),
              juniper_routing_options
            ),
            b(str("protocols"),
                c(
                    b(str("bfd"),
                      juniper_ri_protocols_bfd
                    ),
                    b(str("rsvp"),
                      juniper_protocols_rsvp
                    ),
                    b(str("ospf"),
                      juniper_protocols_ospf
                    ),
                    b(str("ospf3"),
                        c(
                            a(str("realm"), str("ipv6-unicast") | str("ipv6-multicast") | str("ipv4-unicast") | str("ipv4-multicast"),
                                c(
                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                        c(
                                            str("disable"),
                                            a(str("topology-id"), arg),
                                            str("overload"),
                                            a(str("rib-group"), arg),
                                            b(str("spf-options"),
                                                c(
                                                    a(str("delay"), arg),
                                                    a(str("holddown"), arg),
                                                    a(str("rapid-runs"), arg),
                                                    str("no-ignore-our-externals")
                                                )
                                            ),
                                            b(str("backup-spf-options"),
                                                c(
                                                    b(str("remote-backup-calculation"),
                                                        c(
                                                            b(str("pq-nodes-nearest-to-source"),
                                                                c(
                                                                    a(str("percent"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("use-post-convergence-lfa"),
                                                        c(
                                                            a(str("maximum-labels"), arg),
                                                            a(str("maximum-backup-paths"), arg)
                                                        )
                                                    ),
                                                    str("use-source-packet-routing"),
                                                    str("disable"),
                                                    str("no-install"),
                                                    str("downstream-paths-only"),
                                                    b(str("per-prefix-calculation"),
                                                        c(
                                                            str("stubs"),
                                                            str("summary"),
                                                            str("externals"),
                                                            str("all")
                                                        )
                                                    ),
                                                    str("node-link-degradation")
                                                )
                                            ),
                                            a(str("prefix-export-limit"), arg)
                                        )
                                    ),
                                    b(str("backup-spf-options"),
                                        c(
                                            b(str("remote-backup-calculation"),
                                                c(
                                                    b(str("pq-nodes-nearest-to-source"),
                                                        c(
                                                            a(str("percent"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("use-post-convergence-lfa"),
                                                c(
                                                    a(str("maximum-labels"), arg),
                                                    a(str("maximum-backup-paths"), arg)
                                                )
                                            ),
                                            str("use-source-packet-routing"),
                                            str("disable"),
                                            str("no-install"),
                                            str("downstream-paths-only"),
                                            b(str("per-prefix-calculation"),
                                                c(
                                                    str("stubs"),
                                                    str("summary"),
                                                    str("externals"),
                                                    str("all")
                                                )
                                            ),
                                            str("node-link-degradation")
                                        )
                                    ),
                                    b(str("traffic-engineering"),
                                        c(
                                            str("no-topology"),
                                            str("multicast-rpf-routes"),
                                            str("igp-topology"),
                                            str("ignore-lsp-metrics"),
                                            b(str("shortcuts"),
                                                c(
                                                    str("ignore-lsp-metrics"),
                                                    str("lsp-metric-into-summary"),
                                                    a(str("family"), enum(str("inet") | str("inet-mpls")))
                                                )
                                            ),
                                            str("advertise-unnumbered-interfaces"),
                                            str("credibility-protocol-preference"),
                                            b(str("advertisement"),
                                                c(
                                                    str("always")
                                                )
                                            )
                                        )
                                    ),
                                    b(str("source-packet-routing"),
                                        c(
                                            b(str("adjacency-segment"),
                                                c(
                                                    a(str("hold-time"), arg)
                                                )
                                            ),
                                            b(str("prefix-segment"),
                                              policy_algebra
                                            ),
                                            str("explicit-null"),
                                            b(str("node-segment"),
                                                c(
                                                    a(str("ipv4-index"), arg),
                                                    a(str("index-range"), arg)
                                                )
                                            ),
                                            b(str("srgb"),
                                                sc(
                                                    a(str("start-label"), arg),
                                                    a(str("index-range"), arg)
                                                )
                                            ).as(:oneline),
                                            a(str("mapping-server"), arg),
                                            str("install-prefix-sid-for-best-route"),
                                            str("ldp-stitching")
                                        )
                                    ),
                                    b(a(str("area"), arg),
                                        c(
                                            c(
                                              b(str("stub"),
                                                  sc(
                                                      a(str("default-metric"), arg),
                                                      str("summaries"),
                                                      str("no-summaries")
                                                  )
                                              ).as(:oneline),
                                              b(str("nssa"),
                                                  c(
                                                      b(str("default-lsa"),
                                                          c(
                                                              a(str("default-metric"), arg),
                                                              a(str("metric-type"), arg),
                                                              str("type-7")
                                                          )
                                                      ),
                                                      a(str("default-metric"), arg),
                                                      a(str("metric-type"), arg),
                                                      str("summaries"),
                                                      str("no-summaries"),
                                                      b(a(str("area-range"), arg),
                                                          c(
                                                              str("restrict"),
                                                              str("exact"),
                                                              b(str("override-metric"),
                                                                  ca(
                                                                      a(str("metric-type"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                            ),
                                            b(a(str("area-range"), arg),
                                                c(
                                                    str("restrict"),
                                                    str("exact"),
                                                    a(str("override-metric"), arg)
                                                )
                                            ),
                                            b(str("network-summary-export"),
                                              policy_algebra
                                            ),
                                            b(str("network-summary-import"),
                                              policy_algebra
                                            ),
                                            b(str("inter-area-prefix-export"),
                                              policy_algebra
                                            ),
                                            b(str("inter-area-prefix-import"),
                                              policy_algebra
                                            ),
                                            b(str("authentication-type"),
                                              (str("none") | str("simple") | str("md5"))
                                            ),
                                            b(str("virtual-link"),
                                                s(
                                                  a(str("neighbor-id"), arg),
                                                  a(str("transit-area"), arg),
                                                  c(
                                                      (str("disable")),
                                                    a(str("retransmit-interval"), arg),
                                                    a(str("transit-delay"), arg),
                                                    a(str("hello-interval"), arg),
                                                    a(str("dead-interval"), arg),
                                                    a(str("mtu"), arg),
                                                    c(
                                                      b(str("authentication"),
                                                        juniper_ospf_authentication
                                                      ),
                                                      b(str("authentication-key"),
                                                          sc(
                                                                unreadable,
                                                              a(str("key-id"), arg)
                                                          )
                                                      ).as(:oneline)
                                                    ),
                                                    str("demand-circuit"),
                                                    str("flood-reduction"),
                                                    str("no-neighbor-down-notification"),
                                                    a(str("ipsec-sa"), arg),
                                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                                        c(
                                                            str("disable"),
                                                            a(str("metric"), arg),
                                                            b(str("bandwidth-based-metrics"),
                                                                c(
                                                                    b(a(str("bandwidth"), arg),
                                                                        sc(
                                                                            a(str("metric"), arg)
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            )
                                                        )
                                                    )
                                                  )
                                                )
                                            ),
                                            b(a(str("sham-link-remote"), arg),
                                                c(
                                                    a(str("metric"), arg),
                                                    a(str("ipsec-sa"), arg),
                                                    str("demand-circuit"),
                                                    str("flood-reduction"),
                                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                                        c(
                                                            str("disable"),
                                                            a(str("metric"), arg),
                                                            b(str("bandwidth-based-metrics"),
                                                                c(
                                                                    b(a(str("bandwidth"), arg),
                                                                        sc(
                                                                            a(str("metric"), arg)
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(a(str("interface"), arg),
                                                c(
                                                      (str("disable")),
                                                    b(str("interface-type"),
                                                      (str("nbma") | str("p2mp") | str("p2p") | str("p2mp-over-lan"))
                                                    ),
                                                    c(
                                                      str("link-protection"),
                                                      str("node-link-protection")
                                                    ),
                                                    str("no-eligible-backup"),
                                                    str("no-eligible-remote-backup"),
                                                    b(str("passive"),
                                                        c(
                                                            b(str("traffic-engineering"),
                                                                c(
                                                                    b(str("remote-node-id"),
                                                                      ipaddr
                                                                    ),
                                                                    b(str("remote-node-router-id"),
                                                                      ipv4addr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    str("secondary"),
                                                    str("own-router-lsa"),
                                                    b(str("bandwidth-based-metrics"),
                                                        c(
                                                            b(a(str("bandwidth"), arg),
                                                                sc(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    a(str("metric"), arg),
                                                    a(str("priority"), arg),
                                                    a(str("retransmit-interval"), arg),
                                                    a(str("transit-delay"), arg),
                                                    a(str("hello-interval"), arg),
                                                    a(str("dead-interval"), arg),
                                                    a(str("mtu"), arg),
                                                    c(
                                                      b(str("authentication"),
                                                        juniper_ospf_authentication
                                                      ),
                                                      b(str("authentication-key"),
                                                          sc(
                                                                unreadable,
                                                              a(str("key-id"), arg)
                                                          )
                                                      ).as(:oneline)
                                                    ),
                                                    str("demand-circuit"),
                                                    str("flood-reduction"),
                                                    str("no-neighbor-down-notification"),
                                                    a(str("ipsec-sa"), arg),
                                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                                        c(
                                                            str("disable"),
                                                            a(str("metric"), arg),
                                                            b(str("bandwidth-based-metrics"),
                                                                c(
                                                                    b(a(str("bandwidth"), arg),
                                                                        sc(
                                                                            a(str("metric"), arg)
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    a(str("transmit-interval"), arg),
                                                    b(str("bfd-liveness-detection"),
                                                        c(
                                                            b(str("version"),
                                                              (str("0") | str("1") | str("automatic"))
                                                            ),
                                                            a(str("minimum-interval"), arg),
                                                            a(str("minimum-transmit-interval"), arg),
                                                            a(str("minimum-receive-interval"), arg),
                                                            a(str("multiplier"), arg),
                                                            c(
                                                              str("no-adaptation")
                                                            ),
                                                            b(str("transmit-interval"),
                                                                c(
                                                                    a(str("minimum-interval"), arg),
                                                                    a(str("threshold"), arg)
                                                                )
                                                            ),
                                                            b(str("detection-time"),
                                                                c(
                                                                    a(str("threshold"), arg)
                                                                )
                                                            ),
                                                            b(str("authentication"),
                                                                c(
                                                                    a(str("key-chain"), arg),
                                                                    b(str("algorithm"),
                                                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                                    ),
                                                                    str("loose-check")
                                                                )
                                                            ),
                                                            str("full-neighbors-only")
                                                        )
                                                    ),
                                                    str("dynamic-neighbors"),
                                                    str("no-advertise-adjacency-segment"),
                                                    b(a(str("neighbor"), arg),
                                                        sc(
                                                            str("eligible")
                                                        )
                                                    ).as(:oneline),
                                                    a(str("poll-interval"), arg),
                                                    str("no-interface-state-traps"),
                                                    b(str("post-convergence-lfa"),
                                                        c(
                                                            b(str("node-protection"),
                                                                c(
                                                                    a(str("cost"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    a(str("te-metric"), arg),
                                                    b(str("ldp-synchronization"),
                                                      ldp_sync_obj
                                                    ),
                                                    b(str("ipv4-adjacency-segment"),
                                                        c(
                                                            b(str("protected"),
                                                                sc(
                                                                    c(
                                                                      b(str("index"),
                                                                          sc(
                                                                                arg
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("label"), arg),
                                                                      str("dynamic")
                                                                    )
                                                                )
                                                            ).as(:oneline),
                                                            b(str("unprotected"),
                                                                sc(
                                                                    c(
                                                                      b(str("index"),
                                                                          sc(
                                                                                arg
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("label"), arg),
                                                                      str("dynamic")
                                                                    )
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    b(a(str("lan-neighbor"), arg),
                                                        c(
                                                            b(str("ipv4-adjacency-segment"),
                                                                c(
                                                                    b(str("protected"),
                                                                        sc(
                                                                            c(
                                                                              b(str("index"),
                                                                                  sc(
                                                                                        arg
                                                                                  )
                                                                              ).as(:oneline),
                                                                              a(str("label"), arg),
                                                                              str("dynamic")
                                                                            )
                                                                        )
                                                                    ).as(:oneline),
                                                                    b(str("unprotected"),
                                                                        sc(
                                                                            c(
                                                                              b(str("index"),
                                                                                  sc(
                                                                                        arg
                                                                                  )
                                                                              ).as(:oneline),
                                                                              a(str("label"), arg),
                                                                              str("dynamic")
                                                                            )
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            str("no-context-identifier-advertisement"),
                                            b(a(str("peer-interface"), arg),
                                                c(
                                                      (str("disable")),
                                                    a(str("retransmit-interval"), arg),
                                                    a(str("transit-delay"), arg),
                                                    a(str("hello-interval"), arg),
                                                    a(str("dead-interval"), arg),
                                                    a(str("mtu"), arg),
                                                    c(
                                                      b(str("authentication"),
                                                        juniper_ospf_authentication
                                                      ),
                                                      b(str("authentication-key"),
                                                          sc(
                                                                unreadable,
                                                              a(str("key-id"), arg)
                                                          )
                                                      ).as(:oneline)
                                                    ),
                                                    str("demand-circuit"),
                                                    str("flood-reduction"),
                                                    str("no-neighbor-down-notification")
                                                )
                                            ),
                                            str("no-source-packet-routing"),
                                            a(str("context-identifier"), arg),
                                            b(a(str("label-switched-path"), arg),
                                                c(
                                                      (str("disable")),
                                                    a(str("metric"), arg),
                                                    a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                                        c(
                                                            str("disable"),
                                                            a(str("metric"), arg),
                                                            b(str("bandwidth-based-metrics"),
                                                                c(
                                                                    b(a(str("bandwidth"), arg),
                                                                        sc(
                                                                            a(str("metric"), arg)
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                      (str("disable")),
                                    b(str("traceoptions"),
                                        c(
                                            b(str("file"),
                                                sc(
                                                      arg,
                                                    str("replace"),
                                                    a(str("size"), arg),
                                                    a(str("files"), arg),
                                                    str("no-stamp"),
                                                    str("world-readable"),
                                                    str("no-world-readable")
                                                )
                                            ).as(:oneline),
                                            a(str("flag"), enum(str("spf") | str("error") | str("event") | str("packet-dump") | str("flooding") | str("lsa-analysis") | str("packets") | str("hello") | str("database-description") | str("lsa-request") | str("lsa-update") | str("lsa-ack") | str("ldp-synchronization") | str("on-demand") | str("nsr-synchronization") | str("graceful-restart") | str("restart-signaling") | str("backup-spf") | str("source-packet-routing") | str("post-convergence-lfa") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                                sc(
                                                    str("send"),
                                                    str("receive"),
                                                    str("detail"),
                                                    str("disable")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("spf-options"),
                                        c(
                                            a(str("delay"), arg),
                                            a(str("holddown"), arg),
                                            a(str("rapid-runs"), arg),
                                            str("no-ignore-our-externals")
                                        )
                                    ),
                                    a(str("prefix-export-limit"), arg),
                                    b(str("rib-groups"),
                                        c(
                                            a(str("inet"), arg),
                                            a(str("inet3"), arg)
                                        )
                                    ),
                                    str("job-stats"),
                                    b(str("overload"),
                                        c(
                                            a(str("timeout"), arg),
                                            str("allow-route-leaking"),
                                            str("stub-network"),
                                            str("intra-area-prefix"),
                                            str("as-external")
                                        )
                                    ),
                                    b(str("database-protection"),
                                        c(
                                            a(str("maximum-lsa"), arg),
                                            str("warning-only"),
                                            a(str("warning-threshold"), arg),
                                            a(str("ignore-count"), arg),
                                            a(str("ignore-time"), arg),
                                            a(str("reset-time"), arg)
                                        )
                                    ),
                                    b(str("graceful-restart"),
                                        c(
                                              (str("disable")),
                                            a(str("restart-duration"), arg),
                                            a(str("notify-duration"), arg),
                                            b(str("helper-disable"),
                                                c(
                                                    c(
                                                      str("standard"),
                                                      str("restart-signaling"),
                                                      str("both")
                                                    )
                                                )
                                            ),
                                            str("no-strict-lsa-checking")
                                        )
                                    ),
                                    b(str("route-type-community"),
                                      (str("iana") | str("vendor"))
                                    ),
                                    b(str("domain-id"),
                                        sc(
                                            ca(
                                              str("disable")
                                            )
                                        )
                                    ).as(:oneline),
                                    c(
                                      a(str("domain-vpn-tag"), arg),
                                      str("no-domain-vpn-tag")
                                    ),
                                    a(str("preference"), arg),
                                    a(str("external-preference"), arg),
                                    a(str("labeled-preference"), arg),
                                    b(str("export"),
                                      policy_algebra
                                    ),
                                    b(str("import"),
                                      policy_algebra
                                    ),
                                    a(str("reference-bandwidth"), arg),
                                    a(str("lsa-refresh-interval"), arg),
                                    a(str("spf-delay"), arg),
                                    str("no-rfc-1583"),
                                    str("forwarding-address-to-broadcast"),
                                    c(
                                      str("no-nssa-abr")
                                    ),
                                    b(str("sham-link"),
                                        c(
                                            b(str("local"),
                                              ipaddr
                                            ),
                                            str("no-advertise-local")
                                        )
                                    )
                                )
                            ),
                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                c(
                                    str("disable"),
                                    a(str("topology-id"), arg),
                                    str("overload"),
                                    a(str("rib-group"), arg),
                                    b(str("spf-options"),
                                        c(
                                            a(str("delay"), arg),
                                            a(str("holddown"), arg),
                                            a(str("rapid-runs"), arg),
                                            str("no-ignore-our-externals")
                                        )
                                    ),
                                    b(str("backup-spf-options"),
                                        c(
                                            b(str("remote-backup-calculation"),
                                                c(
                                                    b(str("pq-nodes-nearest-to-source"),
                                                        c(
                                                            a(str("percent"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("use-post-convergence-lfa"),
                                                c(
                                                    a(str("maximum-labels"), arg),
                                                    a(str("maximum-backup-paths"), arg)
                                                )
                                            ),
                                            str("use-source-packet-routing"),
                                            str("disable"),
                                            str("no-install"),
                                            str("downstream-paths-only"),
                                            b(str("per-prefix-calculation"),
                                                c(
                                                    str("stubs"),
                                                    str("summary"),
                                                    str("externals"),
                                                    str("all")
                                                )
                                            ),
                                            str("node-link-degradation")
                                        )
                                    ),
                                    a(str("prefix-export-limit"), arg)
                                )
                            ),
                            b(str("backup-spf-options"),
                                c(
                                    b(str("remote-backup-calculation"),
                                        c(
                                            b(str("pq-nodes-nearest-to-source"),
                                                c(
                                                    a(str("percent"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("use-post-convergence-lfa"),
                                        c(
                                            a(str("maximum-labels"), arg),
                                            a(str("maximum-backup-paths"), arg)
                                        )
                                    ),
                                    str("use-source-packet-routing"),
                                    str("disable"),
                                    str("no-install"),
                                    str("downstream-paths-only"),
                                    b(str("per-prefix-calculation"),
                                        c(
                                            str("stubs"),
                                            str("summary"),
                                            str("externals"),
                                            str("all")
                                        )
                                    ),
                                    str("node-link-degradation")
                                )
                            ),
                            b(str("traffic-engineering"),
                                c(
                                    str("no-topology"),
                                    str("multicast-rpf-routes"),
                                    str("igp-topology"),
                                    str("ignore-lsp-metrics"),
                                    b(str("shortcuts"),
                                        c(
                                            str("ignore-lsp-metrics"),
                                            str("lsp-metric-into-summary"),
                                            a(str("family"), enum(str("inet") | str("inet-mpls")))
                                        )
                                    ),
                                    str("advertise-unnumbered-interfaces"),
                                    str("credibility-protocol-preference"),
                                    b(str("advertisement"),
                                        c(
                                            str("always")
                                        )
                                    )
                                )
                            ),
                            b(str("source-packet-routing"),
                                c(
                                    b(str("adjacency-segment"),
                                        c(
                                            a(str("hold-time"), arg)
                                        )
                                    ),
                                    b(str("prefix-segment"),
                                      policy_algebra
                                    ),
                                    str("explicit-null"),
                                    b(str("node-segment"),
                                        c(
                                            a(str("ipv4-index"), arg),
                                            a(str("index-range"), arg)
                                        )
                                    ),
                                    b(str("srgb"),
                                        sc(
                                            a(str("start-label"), arg),
                                            a(str("index-range"), arg)
                                        )
                                    ).as(:oneline),
                                    a(str("mapping-server"), arg),
                                    str("install-prefix-sid-for-best-route"),
                                    str("ldp-stitching")
                                )
                            ),
                            b(a(str("area"), arg),
                                c(
                                    c(
                                      b(str("stub"),
                                          sc(
                                              a(str("default-metric"), arg),
                                              str("summaries"),
                                              str("no-summaries")
                                          )
                                      ).as(:oneline),
                                      b(str("nssa"),
                                          c(
                                              b(str("default-lsa"),
                                                  c(
                                                      a(str("default-metric"), arg),
                                                      a(str("metric-type"), arg),
                                                      str("type-7")
                                                  )
                                              ),
                                              a(str("default-metric"), arg),
                                              a(str("metric-type"), arg),
                                              str("summaries"),
                                              str("no-summaries"),
                                              b(a(str("area-range"), arg),
                                                  c(
                                                      str("restrict"),
                                                      str("exact"),
                                                      b(str("override-metric"),
                                                          ca(
                                                              a(str("metric-type"), arg)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                    ),
                                    b(a(str("area-range"), arg),
                                        c(
                                            str("restrict"),
                                            str("exact"),
                                            a(str("override-metric"), arg)
                                        )
                                    ),
                                    b(str("network-summary-export"),
                                      policy_algebra
                                    ),
                                    b(str("network-summary-import"),
                                      policy_algebra
                                    ),
                                    b(str("inter-area-prefix-export"),
                                      policy_algebra
                                    ),
                                    b(str("inter-area-prefix-import"),
                                      policy_algebra
                                    ),
                                    b(str("authentication-type"),
                                      (str("none") | str("simple") | str("md5"))
                                    ),
                                    b(str("virtual-link"),
                                        s(
                                          a(str("neighbor-id"), arg),
                                          a(str("transit-area"), arg),
                                          c(
                                              (str("disable")),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            a(str("mtu"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              ),
                                              b(str("authentication-key"),
                                                  sc(
                                                        unreadable,
                                                      a(str("key-id"), arg)
                                                  )
                                              ).as(:oneline)
                                            ),
                                            str("demand-circuit"),
                                            str("flood-reduction"),
                                            str("no-neighbor-down-notification"),
                                            a(str("ipsec-sa"), arg),
                                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                                c(
                                                    str("disable"),
                                                    a(str("metric"), arg),
                                                    b(str("bandwidth-based-metrics"),
                                                        c(
                                                            b(a(str("bandwidth"), arg),
                                                                sc(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            )
                                          )
                                        )
                                    ),
                                    b(a(str("sham-link-remote"), arg),
                                        c(
                                            a(str("metric"), arg),
                                            a(str("ipsec-sa"), arg),
                                            str("demand-circuit"),
                                            str("flood-reduction"),
                                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                                c(
                                                    str("disable"),
                                                    a(str("metric"), arg),
                                                    b(str("bandwidth-based-metrics"),
                                                        c(
                                                            b(a(str("bandwidth"), arg),
                                                                sc(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("interface"), arg),
                                        c(
                                              (str("disable")),
                                            b(str("interface-type"),
                                              (str("nbma") | str("p2mp") | str("p2p") | str("p2mp-over-lan"))
                                            ),
                                            c(
                                              str("link-protection"),
                                              str("node-link-protection")
                                            ),
                                            str("no-eligible-backup"),
                                            str("no-eligible-remote-backup"),
                                            b(str("passive"),
                                                c(
                                                    b(str("traffic-engineering"),
                                                        c(
                                                            b(str("remote-node-id"),
                                                              ipaddr
                                                            ),
                                                            b(str("remote-node-router-id"),
                                                              ipv4addr
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            str("secondary"),
                                            str("own-router-lsa"),
                                            b(str("bandwidth-based-metrics"),
                                                c(
                                                    b(a(str("bandwidth"), arg),
                                                        sc(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("metric"), arg),
                                            a(str("priority"), arg),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            a(str("mtu"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              ),
                                              b(str("authentication-key"),
                                                  sc(
                                                        unreadable,
                                                      a(str("key-id"), arg)
                                                  )
                                              ).as(:oneline)
                                            ),
                                            str("demand-circuit"),
                                            str("flood-reduction"),
                                            str("no-neighbor-down-notification"),
                                            a(str("ipsec-sa"), arg),
                                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                                c(
                                                    str("disable"),
                                                    a(str("metric"), arg),
                                                    b(str("bandwidth-based-metrics"),
                                                        c(
                                                            b(a(str("bandwidth"), arg),
                                                                sc(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            a(str("transmit-interval"), arg),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    b(str("version"),
                                                      (str("0") | str("1") | str("automatic"))
                                                    ),
                                                    a(str("minimum-interval"), arg),
                                                    a(str("minimum-transmit-interval"), arg),
                                                    a(str("minimum-receive-interval"), arg),
                                                    a(str("multiplier"), arg),
                                                    c(
                                                      str("no-adaptation")
                                                    ),
                                                    b(str("transmit-interval"),
                                                        c(
                                                            a(str("minimum-interval"), arg),
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("detection-time"),
                                                        c(
                                                            a(str("threshold"), arg)
                                                        )
                                                    ),
                                                    b(str("authentication"),
                                                        c(
                                                            a(str("key-chain"), arg),
                                                            b(str("algorithm"),
                                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                            ),
                                                            str("loose-check")
                                                        )
                                                    ),
                                                    str("full-neighbors-only")
                                                )
                                            ),
                                            str("dynamic-neighbors"),
                                            str("no-advertise-adjacency-segment"),
                                            b(a(str("neighbor"), arg),
                                                sc(
                                                    str("eligible")
                                                )
                                            ).as(:oneline),
                                            a(str("poll-interval"), arg),
                                            str("no-interface-state-traps"),
                                            b(str("post-convergence-lfa"),
                                                c(
                                                    b(str("node-protection"),
                                                        c(
                                                            a(str("cost"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            a(str("te-metric"), arg),
                                            b(str("ldp-synchronization"),
                                              ldp_sync_obj
                                            ),
                                            b(str("ipv4-adjacency-segment"),
                                                c(
                                                    b(str("protected"),
                                                        sc(
                                                            c(
                                                              b(str("index"),
                                                                  sc(
                                                                        arg
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("label"), arg),
                                                              str("dynamic")
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    b(str("unprotected"),
                                                        sc(
                                                            c(
                                                              b(str("index"),
                                                                  sc(
                                                                        arg
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("label"), arg),
                                                              str("dynamic")
                                                            )
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(a(str("lan-neighbor"), arg),
                                                c(
                                                    b(str("ipv4-adjacency-segment"),
                                                        c(
                                                            b(str("protected"),
                                                                sc(
                                                                    c(
                                                                      b(str("index"),
                                                                          sc(
                                                                                arg
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("label"), arg),
                                                                      str("dynamic")
                                                                    )
                                                                )
                                                            ).as(:oneline),
                                                            b(str("unprotected"),
                                                                sc(
                                                                    c(
                                                                      b(str("index"),
                                                                          sc(
                                                                                arg
                                                                          )
                                                                      ).as(:oneline),
                                                                      a(str("label"), arg),
                                                                      str("dynamic")
                                                                    )
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    str("no-context-identifier-advertisement"),
                                    b(a(str("peer-interface"), arg),
                                        c(
                                              (str("disable")),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            a(str("mtu"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              ),
                                              b(str("authentication-key"),
                                                  sc(
                                                        unreadable,
                                                      a(str("key-id"), arg)
                                                  )
                                              ).as(:oneline)
                                            ),
                                            str("demand-circuit"),
                                            str("flood-reduction"),
                                            str("no-neighbor-down-notification")
                                        )
                                    ),
                                    str("no-source-packet-routing"),
                                    a(str("context-identifier"), arg),
                                    b(a(str("label-switched-path"), arg),
                                        c(
                                              (str("disable")),
                                            a(str("metric"), arg),
                                            a(str("topology"), str("default") | str("ipv4-multicast") | arg,
                                                c(
                                                    str("disable"),
                                                    a(str("metric"), arg),
                                                    b(str("bandwidth-based-metrics"),
                                                        c(
                                                            b(a(str("bandwidth"), arg),
                                                                sc(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("spf") | str("error") | str("event") | str("packet-dump") | str("flooding") | str("lsa-analysis") | str("packets") | str("hello") | str("database-description") | str("lsa-request") | str("lsa-update") | str("lsa-ack") | str("ldp-synchronization") | str("on-demand") | str("nsr-synchronization") | str("graceful-restart") | str("restart-signaling") | str("backup-spf") | str("source-packet-routing") | str("post-convergence-lfa") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                        sc(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("spf-options"),
                                c(
                                    a(str("delay"), arg),
                                    a(str("holddown"), arg),
                                    a(str("rapid-runs"), arg),
                                    str("no-ignore-our-externals")
                                )
                            ),
                            a(str("prefix-export-limit"), arg),
                            b(str("rib-groups"),
                                c(
                                    a(str("inet"), arg),
                                    a(str("inet3"), arg)
                                )
                            ),
                            str("job-stats"),
                            b(str("overload"),
                                c(
                                    a(str("timeout"), arg),
                                    str("allow-route-leaking"),
                                    str("stub-network"),
                                    str("intra-area-prefix"),
                                    str("as-external")
                                )
                            ),
                            b(str("database-protection"),
                                c(
                                    a(str("maximum-lsa"), arg),
                                    str("warning-only"),
                                    a(str("warning-threshold"), arg),
                                    a(str("ignore-count"), arg),
                                    a(str("ignore-time"), arg),
                                    a(str("reset-time"), arg)
                                )
                            ),
                            b(str("graceful-restart"),
                                c(
                                      (str("disable")),
                                    a(str("restart-duration"), arg),
                                    a(str("notify-duration"), arg),
                                    b(str("helper-disable"),
                                        c(
                                            c(
                                              str("standard"),
                                              str("restart-signaling"),
                                              str("both")
                                            )
                                        )
                                    ),
                                    str("no-strict-lsa-checking")
                                )
                            ),
                            b(str("route-type-community"),
                              (str("iana") | str("vendor"))
                            ),
                            b(str("domain-id"),
                                sc(
                                    ca(
                                      str("disable")
                                    )
                                )
                            ).as(:oneline),
                            c(
                              a(str("domain-vpn-tag"), arg),
                              str("no-domain-vpn-tag")
                            ),
                            a(str("preference"), arg),
                            a(str("external-preference"), arg),
                            a(str("labeled-preference"), arg),
                            b(str("export"),
                              policy_algebra
                            ),
                            b(str("import"),
                              policy_algebra
                            ),
                            a(str("reference-bandwidth"), arg),
                            a(str("lsa-refresh-interval"), arg),
                            a(str("spf-delay"), arg),
                            str("no-rfc-1583"),
                            str("forwarding-address-to-broadcast"),
                            c(
                              str("no-nssa-abr")
                            ),
                            b(str("sham-link"),
                                c(
                                    b(str("local"),
                                      ipaddr
                                    ),
                                    str("no-advertise-local")
                                )
                            )
                        )
                    ),
                    b(str("rip"),
                      juniper_protocols_rip
                    ),
                    b(str("ripng"),
                      juniper_protocols_ripng
                    ),
                    b(str("isis"),
                      juniper_protocols_isis
                    ),
                    b(str("esis"),
                      juniper_protocols_esis
                    ),
                    b(str("l2vpn"),
                      juniper_protocols_l2vpn
                    ),
                    b(str("vpls"),
                      juniper_protocols_l2vpn
                    ),
                    b(str("evpn"),
                      juniper_protocols_l2vpn
                    ),
                    b(str("pim"),
                      juniper_protocols_pim
                    ),
                    b(str("amt"),
                      juniper_protocols_amt
                    ),
                    b(str("ldp"),
                      juniper_protocols_ldp
                    ),
                    b(str("msdp"),
                      juniper_protocols_msdp
                    ),
                    b(str("mvpn"),
                      juniper_protocols_mvpn
                    ),
                    b(str("igmp-snooping"),
                      juniper_ri_protocols_igmp_snooping
                    ),
                    b(str("mld-snooping"),
                      juniper_ri_protocols_mld_snooping
                    ),
                    b(str("bgp"),
                      juniper_protocols_bgp
                    ),
                    b(str("router-discovery"),
                      juniper_protocols_router_discovery
                    ),
                    b(str("mpls"),
                      juniper_protocols_mpls
                    ),
                    b(str("pim-snooping"),
                      juniper_protocols_pim_snooping
                    ),
                    b(str("rstp"),
                      juniper_protocols_stp
                    ),
                    b(str("mstp"),
                      juniper_protocols_mstp
                    ),
                    b(str("vstp"),
                      juniper_protocols_vstp
                    ),
                    b(str("mvrp"),
                      juniper_protocols_mvrp
                    )
                )
            ),
            a(str("description"), quote | arg),
            b(str("vlan-model"),
              (str("one-to-one"))
            ),
            b(str("vtep-source-interface"),
                sc(
                      interface_unit,
                    c(
                      str("inet6"),
                      str("inet")
                    )
                )
            ).as(:oneline),
            b(str("vtep-remote-interface"),
                c(
                    b(a(str("remote-ip"), arg),
                        c(
                            a(str("dynamic-profile"), arg)
                        )
                    ),
                    b(str("default"),
                        c(
                            a(str("dynamic-profile"), arg)
                        )
                    )
                )
            ),
            b(str("remote-vtep-list"),
              ipaddr
            ),
            b(str("remote-vtep-v6-list"),
              ipv6addr
            ),
            b(str("instance-role"),
              (str("access") | str("nni"))
            ),
            b(str("egress-protection"),
                c(
                    str("protector"),
                    b(str("context-identifier"),
                        c(
                              ipv4addr
                        )
                    )
                )
            ),
            c(
              b(str("vlan-id"),
                (str("all") | str("none") | str("inner-all") | arg)
              ),
              b(str("vlan-tags"),
                  sc(
                      a(str("outer"), arg),
                      a(str("inner"), arg)
                  )
              ).as(:oneline)
            ),
            b(str("system"),
                c(
                    b(str("services"),
                        c(
                            b(str("dhcp-local-server"),
                              jdhcp_local_server_type
                            ),
                            b(str("dhcp-proxy-client"),
                              jdhcp_proxy_client_type
                            ),
                            b(str("static-subscribers"),
                              jsscd_static_subscribers_type
                            ),
                            b(str("remote-device-management"),
                                c(
                                    b(str("service-device"),
                                      service_device_object
                                    )
                                )
                            ),
                            b(str("tcp-forwarding"),
                                c(
                                    b(str("listening-port"),
                                        s(
                                                arg,
                                          a(str("listening-address"), arg),
                                          c(
                                            b(str("forwarding-address"),
                                              ipv4addr
                                            ),
                                            a(str("forwarding-port"), arg),
                                            a(str("max-connections"), arg),
                                            a(str("allowed-source"), arg)
                                          )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("access"),
                c(
                    b(str("address-assignment"),
                      address_assignment_type
                    ),
                    b(str("address-protection"),
                        c(
                            str("reassign-on-match")
                        )
                    )
                )
            ),
            b(str("access-profile"),
                sc(
                    arg
                )
            ).as(:oneline),
            a(str("interface"), arg | arg,
                c(
                    c(
                      str("any"),
                      str("unicast"),
                      str("multicast")
                    ),
                    str("primary"),
                    b(str("protect-interface"),
                      interface_name
                    )
                )
            ),
            b(str("routing-interface"),
              interface_unit
            ),
            b(str("vxlan"),
                c(
                    str("ovsdb-managed"),
                    a(str("vni"), arg),
                    b(str("multicast-group"),
                      ipv4addr
                    ),
                    b(str("multicast-v6-group"),
                      ipv6addr
                    ),
                    str("encapsulate-inner-vlan"),
                    str("decapsulate-accept-inner-vlan"),
                    a(str("unreachable-vtep-aging-timer"), arg),
                    str("ingress-node-replication")
                )
            ),
            b(str("l3-interface"),
              interface_unit
            ),
            str("no-local-switching"),
            str("no-normalization"),
            str("qualified-bum-pruning-mode"),
            str("no-irb-layer-2-copy"),
            b(str("l2vpn-id"),
                c(
                    arg
                )
            ),
            b(str("provider-tunnel"),
                c(
                    c(
                      b(str("rsvp-te"),
                          c(
                              c(
                                a(str("static-lsp"), arg),
                                b(str("label-switched-path-template"),
                                    c(
                                        ca(
                                          str("default-template")
                                        )
                                    )
                                )
                              )
                          )
                      ),
                      str("ldp-p2mp"),
                      b(str("ingress-replication"),
                          c(
                              str("create-new-ucast-tunnel"),
                              b(str("label-switched-path"),
                                  c(
                                      b(str("label-switched-path-template"),
                                          c(
                                              ca(
                                                str("default-template")
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("pim-asm"),
                          c(
                              b(str("group-address"),
                                ipv4addr
                              ),
                              b(str("family"),
                                  c(
                                      b(str("inet"),
                                          c(
                                              b(str("group-address"),
                                                ipv4addr
                                              ),
                                              b(str("tunnel-source"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      b(str("inet6"),
                                          c(
                                              b(str("group-address"),
                                                ipv4addr
                                              ),
                                              b(str("tunnel-source"),
                                                ipv4addr
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("pim-ssm"),
                          c(
                              b(str("group-address"),
                                ipv4addr
                              ),
                              b(str("family"),
                                  c(
                                      b(str("inet"),
                                          c(
                                              b(str("group-address"),
                                                ipv4addr
                                              ),
                                              b(str("tunnel-source"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      b(str("inet6"),
                                          c(
                                              b(str("group-address"),
                                                ipv4addr
                                              ),
                                              b(str("tunnel-source"),
                                                ipv4addr
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      )
                    ),
                    b(str("inter-as"),
                        c(
                            c(
                              b(str("ingress-replication"),
                                  c(
                                      str("create-new-ucast-tunnel"),
                                      b(str("label-switched-path"),
                                          c(
                                              b(str("label-switched-path-template"),
                                                  c(
                                                      ca(
                                                        str("default-template")
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("rsvp-te"),
                                  c(
                                      c(
                                        b(str("label-switched-path-template"),
                                            c(
                                                ca(
                                                  str("default-template")
                                                )
                                            )
                                        )
                                      )
                                  )
                              ),
                              str("ldp-p2mp")
                            ),
                            b(str("inter-region-segmented"),
                                c(
                                    a(str("threshold"), arg),
                                    a(str("fan-out"), arg)
                                )
                            )
                        )
                    ),
                    b(str("inter-region"),
                        c(
                            c(
                              a(str("template"), arg),
                              str("no-inter-region-segmentation")
                            )
                        )
                    ),
                    b(str("inter-region-segmented"),
                        c(
                            a(str("fan-out"), arg)
                        )
                    ),
                    b(str("selective"),
                        c(
                            a(str("tunnel-limit"), arg),
                            a(str("leaf-tunnel-limit-inet"), arg),
                            a(str("leaf-tunnel-limit-inet6"), arg),
                            b(str("wildcard-group-inet"),
                                c(
                                    b(str("wildcard-source"),
                                        c(
                                            a(str("threshold-rate"), arg),
                                            c(
                                              b(str("ingress-replication"),
                                                  c(
                                                      str("create-new-ucast-tunnel"),
                                                      b(str("label-switched-path"),
                                                          c(
                                                              b(str("label-switched-path-template"),
                                                                  c(
                                                                      ca(
                                                                        str("default-template")
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("rsvp-te"),
                                                  c(
                                                      c(
                                                        a(str("static-lsp"), arg),
                                                        b(str("label-switched-path-template"),
                                                            c(
                                                                ca(
                                                                  str("default-template")
                                                                )
                                                            )
                                                        )
                                                      )
                                                  )
                                              ),
                                              str("ldp-p2mp"),
                                              b(str("pim-ssm"),
                                                  c(
                                                      b(str("group-range"),
                                                        ipv4prefix
                                                      )
                                                  )
                                              )
                                            ),
                                            b(str("inter-region-segmented"),
                                                c(
                                                    a(str("fan-out"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("wildcard-group-inet6"),
                                c(
                                    b(str("wildcard-source"),
                                        c(
                                            a(str("threshold-rate"), arg),
                                            c(
                                              b(str("ingress-replication"),
                                                  c(
                                                      str("create-new-ucast-tunnel"),
                                                      b(str("label-switched-path"),
                                                          c(
                                                              b(str("label-switched-path-template"),
                                                                  c(
                                                                      ca(
                                                                        str("default-template")
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("rsvp-te"),
                                                  c(
                                                      c(
                                                        a(str("static-lsp"), arg),
                                                        b(str("label-switched-path-template"),
                                                            c(
                                                                ca(
                                                                  str("default-template")
                                                                )
                                                            )
                                                        )
                                                      )
                                                  )
                                              ),
                                              str("ldp-p2mp"),
                                              b(str("pim-ssm"),
                                                  c(
                                                      b(str("group-range"),
                                                        ipv4prefix
                                                      )
                                                  )
                                              )
                                            ),
                                            b(str("inter-region-segmented"),
                                                c(
                                                    a(str("fan-out"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("group"), arg),
                                c(
                                    b(str("wildcard-source"),
                                        c(
                                            a(str("threshold-rate"), arg),
                                            c(
                                              b(str("ingress-replication"),
                                                  c(
                                                      str("create-new-ucast-tunnel"),
                                                      b(str("label-switched-path"),
                                                          c(
                                                              b(str("label-switched-path-template"),
                                                                  c(
                                                                      ca(
                                                                        str("default-template")
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("rsvp-te"),
                                                  c(
                                                      c(
                                                        a(str("static-lsp"), arg),
                                                        b(str("label-switched-path-template"),
                                                            c(
                                                                ca(
                                                                  str("default-template")
                                                                )
                                                            )
                                                        )
                                                      )
                                                  )
                                              ),
                                              str("ldp-p2mp"),
                                              b(str("pim-ssm"),
                                                  c(
                                                      b(str("group-range"),
                                                        ipv4prefix
                                                      )
                                                  )
                                              )
                                            ),
                                            b(str("inter-region-segmented"),
                                                c(
                                                    a(str("threshold"), arg),
                                                    a(str("fan-out"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("source"), arg),
                                        c(
                                            c(
                                              b(str("ingress-replication"),
                                                  c(
                                                      str("create-new-ucast-tunnel"),
                                                      b(str("label-switched-path"),
                                                          c(
                                                              b(str("label-switched-path-template"),
                                                                  c(
                                                                      ca(
                                                                        str("default-template")
                                                                      )
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("rsvp-te"),
                                                  c(
                                                      c(
                                                        a(str("static-lsp"), arg),
                                                        b(str("label-switched-path-template"),
                                                            c(
                                                                ca(
                                                                  str("default-template")
                                                                )
                                                            )
                                                        )
                                                      )
                                                  )
                                              ),
                                              b(str("pim-ssm"),
                                                  c(
                                                      b(str("group-range"),
                                                        ipv4prefix
                                                      )
                                                  )
                                              ),
                                              str("ldp-p2mp")
                                            ),
                                            a(str("threshold-rate"), arg),
                                            b(str("inter-region-segmented"),
                                                c(
                                                    a(str("threshold"), arg),
                                                    a(str("fan-out"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("mdt"),
                        c(
                            b(str("threshold"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            b(a(str("source"), arg),
                                                c(
                                                    a(str("rate"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            str("data-mdt-reuse"),
                            a(str("tunnel-limit"), arg),
                            b(str("group-range"),
                              ipprefix
                            )
                        )
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    c(
                                      b(str("rsvp-te"),
                                          c(
                                              c(
                                                a(str("static-lsp"), arg),
                                                b(str("label-switched-path-template"),
                                                    c(
                                                        ca(
                                                          str("default-template")
                                                        )
                                                    )
                                                )
                                              )
                                          )
                                      ),
                                      str("ldp-p2mp"),
                                      b(str("ingress-replication"),
                                          c(
                                              str("create-new-ucast-tunnel"),
                                              b(str("label-switched-path"),
                                                  c(
                                                      b(str("label-switched-path-template"),
                                                          c(
                                                              ca(
                                                                str("default-template")
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("pim-asm"),
                                          c(
                                              b(str("group-address"),
                                                ipv4addr
                                              ),
                                              b(str("tunnel-source"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      b(str("pim-ssm"),
                                          c(
                                              b(str("group-address"),
                                                ipv4addr
                                              ),
                                              b(str("tunnel-source"),
                                                ipv4addr
                                              )
                                          )
                                      )
                                    ),
                                    b(str("mdt"),
                                        c(
                                            b(str("threshold"),
                                                c(
                                                    b(a(str("group"), arg),
                                                        c(
                                                            b(a(str("source"), arg),
                                                                c(
                                                                    a(str("rate"), arg)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            str("data-mdt-reuse"),
                                            a(str("tunnel-limit"), arg),
                                            b(str("group-range"),
                                              ipprefix
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    c(
                                      b(str("rsvp-te"),
                                          c(
                                              c(
                                                a(str("static-lsp"), arg),
                                                b(str("label-switched-path-template"),
                                                    c(
                                                        ca(
                                                          str("default-template")
                                                        )
                                                    )
                                                )
                                              )
                                          )
                                      ),
                                      str("ldp-p2mp"),
                                      b(str("ingress-replication"),
                                          c(
                                              str("create-new-ucast-tunnel"),
                                              b(str("label-switched-path"),
                                                  c(
                                                      b(str("label-switched-path-template"),
                                                          c(
                                                              ca(
                                                                str("default-template")
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("pim-asm"),
                                          c(
                                              b(str("group-address"),
                                                ipv4addr
                                              ),
                                              b(str("tunnel-source"),
                                                ipv4addr
                                              )
                                          )
                                      ),
                                      b(str("pim-ssm"),
                                          c(
                                              b(str("group-address"),
                                                ipv4addr
                                              ),
                                              b(str("tunnel-source"),
                                                ipv4addr
                                              )
                                          )
                                      )
                                    ),
                                    b(str("mdt"),
                                        c(
                                            b(str("threshold"),
                                                c(
                                                    b(a(str("group"), arg),
                                                        c(
                                                            b(a(str("source"), arg),
                                                                c(
                                                                    a(str("rate"), arg)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            str("data-mdt-reuse"),
                                            a(str("tunnel-limit"), arg),
                                            b(str("group-range"),
                                              ipprefix
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            str("connector-id-advertise"),
            b(str("forwarding-options"),
              juniper_forwarding_options
            ),
            b(str("multicast-snooping-options"),
              juniper_multicast_snooping_options
            ),
            b(str("igmp-snooping-options"),
              juniper_igmp_snooping_options
            ),
            b(str("mld-snooping-options"),
              juniper_mld_snooping_options
            ),
            b(str("bridge-domains"),
                c(
                      juniper_bridge_domains
                )
            ),
            b(str("switch-options"),
              juniper_routing_instance_switch_options
            ),
            b(str("pbb-options"),
              juniper_routing_instance_pbb_options
            ),
            b(str("service-groups"),
              juniper_routing_instance_service_groups
            ),
            a(str("layer3-domain-identifier"), arg),
            a(str("l2-domain-id-for-l3"), arg),
            b(str("route-distinguisher"),
                sc(
                    arg
                )
            ).as(:oneline),
            b(str("vrf-import"),
              policy_algebra
            ),
            b(str("vrf-export"),
              policy_algebra
            ),
            b(str("vrf-target"),
                ca(
                    a(str("import"), arg),
                    a(str("export"), arg),
                    str("auto")
                )
            ),
            str("no-vrf-advertise"),
            str("non-forwarding-vrf"),
            b(str("vrf-advertise-selective"),
                c(
                    b(str("family"),
                        c(
                            str("inet-mvpn"),
                            str("inet6-mvpn")
                        )
                    )
                )
            ),
            b(str("vrf-table-label"),
                sc(
                    a(str("static"), arg),
                    str("source-class-usage")
                )
            ).as(:oneline),
            c(
              str("no-vrf-propagate-ttl"),
              str("vrf-propagate-ttl")
            ),
            b(str("vlans"),
                c(
                      vlan_types
                )
            )
        )
      )
    end

    rule(:juniper_igmp_snooping_options) do
        c(
            str("use-p2mp-lsp"),
            str("snoop-pseudowires")
        )
    end

    rule(:juniper_mld_snooping_options) do
        c(
            str("use-p2mp-lsp"),
            str("snoop-pseudowires")
        )
    end

    rule(:juniper_protocols_l2vpn) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("error") | str("topology") | str("nlri") | str("connections") | str("automatic-site") | str("oam") | str("mac-database") | str("nsr") | str("egress-protection") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("encapsulation-type"),
              (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
            ),
            c(
              str("control-word"),
              str("no-control-word")
            ),
            a(str("site-range"), arg),
            str("bum-hashing"),
            str("enable-mac-move-action"),
            str("mac-pinning"),
            b(str("label-block-size"),
              (str("2") | str("4") | str("8") | str("16"))
            ),
            b(str("mac-table-size"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop"))
                    )
                )
            ),
            b(str("mac-ip-table-size"),
                c(
                      arg
                )
            ),
            b(str("interface-mac-limit"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                    )
                )
            ),
            b(str("interface-mac-ip-limit"),
                c(
                      arg
                )
            ),
            b(str("mac-notification"),
                c(
                    a(str("notification-interval"), arg)
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("no-normalization"),
            str("mac-statistics"),
            b(str("mib"),
                c(
                    b(str("dot1q-mib"),
                        c(
                            b(str("port-list"),
                              (str("bit-map") | str("string"))
                            )
                        )
                    )
                )
            ),
            b(str("static-rvtep-mac"),
                c(
                    b(str("mac"),
                        s(
                                arg,
                          a(str("remote-vtep"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        ca(
                            str("disable"),
                            b(str("packet-action"),
                              (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                            )
                        )
                    ),
                    b(str("vpws-service-id"),
                        c(
                            a(str("local"), arg),
                            a(str("remote"), arg)
                        )
                    ),
                    b(str("protect-interface"),
                      interface_name
                    ),
                    a(str("action-priority"), arg),
                    a(str("remote-site-id"), arg),
                    a(str("target-attachment-identifier"), arg),
                    str("flow-label-transmit"),
                    str("flow-label-receive"),
                    b(str("encapsulation-type"),
                      (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
                    ),
                    str("ignore-encapsulation-mismatch"),
                    a(str("mtu"), arg),
                    str("ignore-mtu-mismatch"),
                    c(
                      str("control-word"),
                      str("no-control-word")
                    ),
                    str("pseudowire-status-tlv"),
                    b(str("oam"),
                        c(
                            a(str("ping-interval"), arg),
                            a(str("ping-multiplier"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("community"), arg),
                    b(a(str("static-mac"), arg),
                        c(
                            a(str("vlan-id"), arg)
                        )
                    ),
                    b(str("interface-mac-ip-limit"),
                        c(
                              arg
                        )
                    ),
                    str("no-mac-learning"),
                    str("mac-pinning"),
                    a(str("description"), quote | arg),
                    str("persistent-learning")
                )
            ),
            c(
              b(str("tunnel-services"),
                  c(
                      b(str("devices"),
                        interface_device
                      ),
                      b(str("primary"),
                        interface_device
                      )
                  )
              ),
              str("no-tunnel-services")
            ),
            b(a(str("site"), arg),
                c(
                    c(
                      a(str("site-identifier"), arg),
                      b(str("automatic-site-id"),
                          c(
                              a(str("startup-wait-time"), arg),
                              a(str("new-site-wait-time"), arg),
                              a(str("collision-detect-time"), arg),
                              b(str("reclaim-wait-time"),
                                  sc(
                                      a(str("minimum"), arg),
                                      a(str("maximum"), arg)
                                  )
                              ).as(:oneline)
                          )
                      )
                    ),
                    a(str("source-attachment-identifier"), arg),
                    str("flow-label-transmit"),
                    str("flow-label-receive"),
                    b(str("encapsulation-type"),
                      (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
                    ),
                    str("ignore-encapsulation-mismatch"),
                    c(
                      str("control-word"),
                      str("no-control-word")
                    ),
                    str("pseudowire-status-tlv"),
                    b(str("oam"),
                        c(
                            a(str("ping-interval"), arg),
                            a(str("ping-multiplier"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("community"), arg),
                    b(str("multi-homing"),
                        c(
                            a(str("hold-time"), arg)
                        )
                    ),
                    str("mac-pinning"),
                    b(str("site-preference"),
                      (str("primary") | str("backup") | arg)
                    ),
                    str("hot-standby"),
                    a(str("mtu"), arg),
                    str("ignore-mtu-mismatch"),
                    a(str("mesh-group"), arg),
                    b(str("active-interface"),
                        sc(
                            c(
                              str("any"),
                              b(str("primary"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    str("best-site"),
                    b(a(str("interface"), arg),
                        c(
                            b(str("interface-mac-limit"),
                                ca(
                                    str("disable"),
                                    b(str("packet-action"),
                                      (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                                    )
                                )
                            ),
                            b(str("vpws-service-id"),
                                c(
                                    a(str("local"), arg),
                                    a(str("remote"), arg)
                                )
                            ),
                            b(str("protect-interface"),
                              interface_name
                            ),
                            a(str("action-priority"), arg),
                            a(str("remote-site-id"), arg),
                            a(str("target-attachment-identifier"), arg),
                            str("flow-label-transmit"),
                            str("flow-label-receive"),
                            b(str("encapsulation-type"),
                              (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
                            ),
                            str("ignore-encapsulation-mismatch"),
                            a(str("mtu"), arg),
                            str("ignore-mtu-mismatch"),
                            c(
                              str("control-word"),
                              str("no-control-word")
                            ),
                            str("pseudowire-status-tlv"),
                            b(str("oam"),
                                c(
                                    a(str("ping-interval"), arg),
                                    a(str("ping-multiplier"), arg),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("version"),
                                              (str("0") | str("1") | str("automatic"))
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("minimum-transmit-interval"), arg),
                                            a(str("minimum-receive-interval"), arg),
                                            a(str("multiplier"), arg),
                                            c(
                                              str("no-adaptation")
                                            ),
                                            b(str("transmit-interval"),
                                                c(
                                                    a(str("minimum-interval"), arg),
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("detection-time"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("community"), arg),
                            b(a(str("static-mac"), arg),
                                c(
                                    a(str("vlan-id"), arg)
                                )
                            ),
                            b(str("interface-mac-ip-limit"),
                                c(
                                      arg
                                )
                            ),
                            str("no-mac-learning"),
                            str("mac-pinning"),
                            a(str("description"), quote | arg),
                            str("persistent-learning")
                        )
                    )
                )
            ),
            a(str("community"), arg),
            a(str("vpls-id"), arg),
            a(str("mtu"), arg),
            str("ignore-mtu-mismatch"),
            b(str("mac-flush"),
                c(
                    str("any-interface"),
                    str("any-spoke"),
                    str("propagate")
                )
            ),
            str("ignore-encapsulation-mismatch"),
            str("pseudowire-status-tlv"),
            b(a(str("neighbor"), arg),
                c(
                    b(str("static"),
                        c(
                            a(str("incoming-label"), arg),
                            a(str("outgoing-label"), arg)
                        )
                    ),
                    b(str("associate-profile"),
                        ca(
                            a(str("profile-variable-set"), arg)
                        )
                    ),
                    b(str("psn-tunnel-endpoint"),
                      ipv4addr
                    ),
                    a(str("community"), arg),
                    str("mac-pinning"),
                    b(str("encapsulation-type"),
                      (str("ethernet-vlan") | str("ethernet"))
                    ),
                    str("ignore-encapsulation-mismatch"),
                    b(str("pseudowire-status-tlv"),
                        c(
                            str("hot-standby-vc-on")
                        )
                    ),
                    a(str("switchover-delay"), arg),
                    b(str("revert-time"),
                        sc(
                              arg,
                            a(str("maximum"), arg)
                        )
                    ).as(:oneline),
                    str("connection-protection"),
                    b(a(str("backup-neighbor"), arg),
                        c(
                            b(str("static"),
                                c(
                                    a(str("incoming-label"), arg),
                                    a(str("outgoing-label"), arg)
                                )
                            ),
                            a(str("community"), arg),
                            b(str("psn-tunnel-endpoint"),
                              ipv4addr
                            ),
                            str("standby"),
                            str("hot-standby")
                        )
                    ),
                    b(str("oam"),
                        c(
                            a(str("ping-interval"), arg),
                            a(str("ping-multiplier"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            str("flow-label-transmit"),
            str("flow-label-receive"),
            str("flow-label-transmit-static"),
            str("flow-label-receive-static"),
            b(str("associate-profile"),
                ca(
                    a(str("profile-variable-set"), arg)
                )
            ),
            b(a(str("mesh-group"), arg),
                c(
                    b(str("associate-profile"),
                        ca(
                            a(str("profile-variable-set"), arg)
                        )
                    ),
                    c(
                      b(str("peer-as"),
                          c(
                              str("all")
                          )
                      )
                    ),
                    a(str("vpls-id"), arg),
                    b(str("vrf-import"),
                      policy_algebra
                    ),
                    b(str("vrf-export"),
                      policy_algebra
                    ),
                    b(str("vrf-target"),
                        ca(
                            a(str("import"), arg),
                            a(str("export"), arg)
                        )
                    ),
                    b(str("mac-flush"),
                        c(
                            str("any-interface"),
                            str("any-spoke"),
                            str("propagate")
                        )
                    ),
                    str("local-switching"),
                    b(a(str("neighbor"), arg),
                        c(
                            b(str("static"),
                                c(
                                    a(str("incoming-label"), arg),
                                    a(str("outgoing-label"), arg)
                                )
                            ),
                            b(str("associate-profile"),
                                ca(
                                    a(str("profile-variable-set"), arg)
                                )
                            ),
                            b(str("psn-tunnel-endpoint"),
                              ipv4addr
                            ),
                            a(str("community"), arg),
                            str("mac-pinning"),
                            b(str("encapsulation-type"),
                              (str("ethernet-vlan") | str("ethernet"))
                            ),
                            str("ignore-encapsulation-mismatch"),
                            b(str("pseudowire-status-tlv"),
                                c(
                                    str("hot-standby-vc-on")
                                )
                            ),
                            a(str("switchover-delay"), arg),
                            b(str("revert-time"),
                                sc(
                                      arg,
                                    a(str("maximum"), arg)
                                )
                            ).as(:oneline),
                            str("connection-protection"),
                            b(a(str("backup-neighbor"), arg),
                                c(
                                    b(str("static"),
                                        c(
                                            a(str("incoming-label"), arg),
                                            a(str("outgoing-label"), arg)
                                        )
                                    ),
                                    a(str("community"), arg),
                                    b(str("psn-tunnel-endpoint"),
                                      ipv4addr
                                    ),
                                    str("standby"),
                                    str("hot-standby")
                                )
                            ),
                            b(str("oam"),
                                c(
                                    a(str("ping-interval"), arg),
                                    a(str("ping-multiplier"), arg),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("version"),
                                              (str("0") | str("1") | str("automatic"))
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("minimum-transmit-interval"), arg),
                                            a(str("minimum-receive-interval"), arg),
                                            a(str("multiplier"), arg),
                                            c(
                                              str("no-adaptation")
                                            ),
                                            b(str("transmit-interval"),
                                                c(
                                                    a(str("minimum-interval"), arg),
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("detection-time"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("vpls-id-list"), arg)
                        )
                    ),
                    a(str("interface"), arg),
                    b(str("route-distinguisher"),
                        sc(
                            arg
                        )
                    ).as(:oneline)
                )
            ),
            b(str("connectivity-type"),
              (str("ce") | str("irb") | str("permanent"))
            ),
            a(str("import-labeled-routes"), arg).as(:oneline),
            b(str("oam"),
                c(
                    a(str("ping-interval"), arg),
                    a(str("ping-multiplier"), arg),
                    b(str("bfd-liveness-detection"),
                        c(
                            b(str("version"),
                              (str("0") | str("1") | str("automatic"))
                            ),
                            a(str("minimum-interval"), arg),
                            a(str("minimum-transmit-interval"), arg),
                            a(str("minimum-receive-interval"), arg),
                            a(str("multiplier"), arg),
                            c(
                              str("no-adaptation")
                            ),
                            b(str("transmit-interval"),
                                c(
                                    a(str("minimum-interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("detection-time"),
                                c(
                                    a(str("threshold"), arg)
                                )
                            )
                        )
                    ),
                    b(str("control-channel"),
                        c(
                            c(
                              str("pwe3-control-word"),
                              str("router-alert-label"),
                              str("pw-label-ttl-1")
                            )
                        )
                    )
                )
            ),
            b(str("multi-homing"),
                c(
                    str("peer-active"),
                    b(a(str("site"), arg),
                        c(
                            a(str("identifier"), arg),
                            b(str("preference"),
                              (str("primary") | str("backup") | arg)
                            ),
                            b(str("active-interface"),
                                c(
                                    c(
                                      str("any"),
                                      b(str("primary"),
                                        interface_name
                                      )
                                    )
                                )
                            ),
                            b(a(str("interface"), arg),
                                c(
                                    a(str("preference"), arg)
                                )
                            ),
                            str("peer-active")
                        )
                    )
                )
            ),
            b(str("evi-options"),
              juniper_protocols_evi_options
            ),
            str("p2mp-bud-support"),
            b(str("remote-ip-host-routes"),
                c(
                    b(str("import"),
                      policy_algebra
                    )
                )
            ),
            str("pbb-evpn-core"),
            b(str("label-allocation"),
              (str("per-instance"))
            ),
            b(str("proxy-mac"),
                c(
                    str("irb"),
                      mac_unicast
                )
            ),
            a(str("designated-forwarder-election-hold-time"), arg),
            str("evpn-etree"),
            a(str("igmp-id"), arg),
            str("designated-forwarder-preference-least"),
            b(str("assisted-replication"),
                c(
                    c(
                      b(str("leaf"),
                          c(
                              a(str("replicator-activation-delay"), arg)
                          )
                      ),
                      b(str("replicator"),
                          c(
                              c(
                                b(str("inet"),
                                    c(
                                          ipv4addr
                                    )
                                )
                              ),
                              b(str("vxlan-encapsulation-source-ip"),
                                (str("ingress-replication-ip"))
                              )
                          )
                      )
                    )
                )
            ),
            b(str("encapsulation"),
              (str("mpls") | str("vxlan"))
            ),
            c(
              a(str("extended-vlan-list"), arg),
              a(str("extended-vni-list"), arg),
              a(str("extended-isid-list"), arg)
            ),
            b(str("mclag"),
                c(
                    b(str("bgp-peer"),
                      ipaddr
                    ),
                    b(str("source-vtep-peer"),
                      ipaddr
                    )
                )
            ),
            b(str("vni-options"),
                c(
                    b(a(str("vni"), arg),
                        c(
                            b(str("vrf-target"),
                                c(
                                    a(str("export"), arg),
                                    arg
                                )
                            )
                        )
                    )
                )
            ),
            b(str("ip-prefix-routes"),
                c(
                    b(str("advertise"),
                      (str("gateway-address") | str("direct-nexthop"))
                    ),
                    b(str("gateway-interface"),
                      interface_unit
                    ),
                    b(str("encapsulation"),
                      (str("mpls") | str("vxlan"))
                    ),
                    a(str("vni"), arg),
                    b(str("import"),
                      policy_algebra
                    ),
                    b(str("export"),
                      policy_algebra
                    )
                )
            ),
            b(str("multicast-mode"),
              (str("ingress-replication"))
            ),
            b(str("vrf-target"),
                c(
                    arg
                )
            ),
            b(str("default-gateway"),
              (str("advertise") | str("no-gateway-community") | str("do-not-advertise"))
            ),
            b(str("duplicate-mac-detection"),
                c(
                    a(str("detection-threshold"), arg),
                    a(str("detection-window"), arg),
                    a(str("auto-recovery-time"), arg)
                )
            ),
            c(
              str("flexible-cross-connect-vlan-aware"),
              str("flexible-cross-connect-vlan-unaware")
            ),
            str("auto-service-id"),
            str("hot-standby-on"),
            b(a(str("group"), arg),
                c(
                    b(str("esi"),
                        c(
                              esi
                        )
                    ),
                    a(str("interface"), arg),
                    b(str("service-id"),
                        c(
                            a(str("local"), arg),
                            a(str("remote"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_evi_options) do
        c(
            b(a(str("isid"), arg),
                c(
                    b(str("vrf-target"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_pim_snooping) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("hello") | str("join") | str("prune") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            str("no-dr-flood"),
            b(a(str("vlan"), arg),
                c(
                    str("no-dr-flood")
                )
            )
        )
    end

    rule(:juniper_ri_protocols_bfd) do
        c(
            b(str("sbfd"),
                c(
                    a(str("pool"), arg),
                    b(a(str("local-discriminator"), arg),
                        c(
                            a(str("minimum-receive-interval"), arg),
                            b(str("local-ip-address"),
                              ipv4addr
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_ri_protocols_igmp_snooping) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("query-interval"), arg),
            b(str("l2-querier"),
                c(
                    b(str("source-address"),
                      ipv4addr
                    )
                )
            ),
            a(str("query-response-interval"), arg),
            a(str("query-last-member-interval"), arg),
            a(str("robust-count"), arg),
            str("learn-pim-router"),
            str("immediate-leave"),
            b(str("proxy"),
                c(
                    b(str("source-address"),
                      ipv4addr
                    ),
                    str("irb")
                )
            ),
            str("evpn-ssm-reports-only"),
            b(a(str("interface"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave"),
                    str("host-only-interface"),
                    a(str("group-limit"), arg),
                    b(str("static"),
                        c(
                            b(a(str("group"), arg),
                                c(
                                    a(str("source"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("pseudowire-remote-address"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave")
                )
            ),
            b(a(str("qualified-vlan"), arg),
                c(
                    a(str("query-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    b(str("proxy"),
                        c(
                            b(str("source-address"),
                              ipv4addr
                            )
                        )
                    ),
                    str("evpn-ssm-reports-only"),
                    b(a(str("interface"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave"),
                            str("host-only-interface"),
                            a(str("group-limit"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            a(str("source"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("pseudowire-remote-address"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave")
                        )
                    )
                )
            ),
            b(a(str("vlan"), arg),
                c(
                    a(str("query-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    b(str("proxy"),
                        c(
                            b(str("source-address"),
                              ipv4addr
                            )
                        )
                    ),
                    str("evpn-ssm-reports-only"),
                    b(a(str("interface"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave"),
                            str("host-only-interface"),
                            a(str("group-limit"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            a(str("source"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("pseudowire-remote-address"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave")
                        )
                    ),
                    b(a(str("qualified-vlan"), arg),
                        c(
                            a(str("query-interval"), arg),
                            a(str("query-response-interval"), arg),
                            a(str("query-last-member-interval"), arg),
                            a(str("robust-count"), arg),
                            str("immediate-leave"),
                            b(str("proxy"),
                                c(
                                    b(str("source-address"),
                                      ipv4addr
                                    )
                                )
                            ),
                            str("evpn-ssm-reports-only"),
                            b(a(str("interface"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave"),
                                    str("host-only-interface"),
                                    a(str("group-limit"), arg),
                                    b(str("static"),
                                        c(
                                            b(a(str("group"), arg),
                                                c(
                                                    a(str("source"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("pseudowire-remote-address"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave")
                                )
                            )
                        )
                    ),
                    str("disable")
                )
            )
        )
    end

    rule(:juniper_ri_protocols_mld_snooping) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("packets") | str("query") | str("report") | str("leave") | str("group") | str("client-notification") | str("host-notification") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("query-interval"), arg),
            b(str("l2-querier"),
                c(
                    b(str("source-address"),
                      ipv6addr
                    )
                )
            ),
            a(str("query-response-interval"), arg),
            a(str("query-last-member-interval"), arg),
            a(str("robust-count"), arg),
            str("immediate-leave"),
            b(str("proxy"),
                c(
                    b(str("source-address"),
                      ipv6addr
                    ),
                    str("irb")
                )
            ),
            str("evpn-ssm-reports-only"),
            b(a(str("interface"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave"),
                    str("host-only-interface"),
                    a(str("group-limit"), arg),
                    b(str("static"),
                        c(
                            b(a(str("group"), arg),
                                c(
                                    a(str("source"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("pseudowire-remote-address"), arg),
                c(
                    str("multicast-router-interface"),
                    str("immediate-leave")
                )
            ),
            b(a(str("qualified-vlan"), arg),
                c(
                    a(str("query-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    b(str("proxy"),
                        c(
                            b(str("source-address"),
                              ipv6addr
                            )
                        )
                    ),
                    str("evpn-ssm-reports-only"),
                    b(a(str("interface"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave"),
                            str("host-only-interface"),
                            a(str("group-limit"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            a(str("source"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("pseudowire-remote-address"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave")
                        )
                    )
                )
            ),
            b(a(str("vlan"), arg),
                c(
                    a(str("query-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    b(str("proxy"),
                        c(
                            b(str("source-address"),
                              ipv6addr
                            )
                        )
                    ),
                    str("evpn-ssm-reports-only"),
                    b(a(str("interface"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave"),
                            str("host-only-interface"),
                            a(str("group-limit"), arg),
                            b(str("static"),
                                c(
                                    b(a(str("group"), arg),
                                        c(
                                            a(str("source"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("pseudowire-remote-address"), arg),
                        c(
                            str("multicast-router-interface"),
                            str("immediate-leave")
                        )
                    ),
                    b(a(str("qualified-vlan"), arg),
                        c(
                            a(str("query-interval"), arg),
                            a(str("query-response-interval"), arg),
                            a(str("query-last-member-interval"), arg),
                            a(str("robust-count"), arg),
                            str("immediate-leave"),
                            b(str("proxy"),
                                c(
                                    b(str("source-address"),
                                      ipv6addr
                                    )
                                )
                            ),
                            str("evpn-ssm-reports-only"),
                            b(a(str("interface"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave"),
                                    str("host-only-interface"),
                                    a(str("group-limit"), arg),
                                    b(str("static"),
                                        c(
                                            b(a(str("group"), arg),
                                                c(
                                                    a(str("source"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("pseudowire-remote-address"), arg),
                                c(
                                    str("multicast-router-interface"),
                                    str("immediate-leave")
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_routing_instance_pbb_options) do
        c(
            a(str("peer-instance"), arg),
            b(a(str("vlan-id"), arg),
                sc(
                    a(str("isid-list"), arg)
                )
            ).as(:oneline),
            a(str("default-bvlan"), arg)
        )
    end

    rule(:juniper_routing_instance_service_groups) do
      b(arg.as(:arg),
        c(
            b(str("service-type"),
              (str("eline") | str("elan"))
            ),
            b(str("pbb-service-options"),
                c(
                    b(a(str("isid"), arg),
                        sc(
                            c(
                              a(str("vlan-id-list"), arg),
                              b(str("interface"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    a(str("default-isid"), arg),
                    b(str("mac-address"),
                      mac_addr
                    ),
                    b(str("source-bmac"),
                      mac_addr
                    )
                )
            )
        )
      )
    end

    rule(:juniper_routing_instance_switch_options) do
        c(
            b(str("mac-table-size"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop"))
                    )
                )
            ),
            b(str("mac-ip-table-size"),
                c(
                      arg
                )
            ),
            b(str("interface-mac-limit"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                    )
                )
            ),
            b(str("interface-mac-ip-limit"),
                c(
                      arg
                )
            ),
            b(str("mac-notification"),
                c(
                    a(str("notification-interval"), arg)
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("no-normalization"),
            str("mac-statistics"),
            b(str("mib"),
                c(
                    b(str("dot1q-mib"),
                        c(
                            b(str("port-list"),
                              (str("bit-map") | str("string"))
                            )
                        )
                    )
                )
            ),
            b(str("static-rvtep-mac"),
                c(
                    b(str("mac"),
                        s(
                                arg,
                          a(str("remote-vtep"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            a(str("service-id"), arg),
            str("ovsdb-managed"),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        ca(
                            str("disable"),
                            b(str("packet-action"),
                              (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                            )
                        )
                    ),
                    b(str("vpws-service-id"),
                        c(
                            a(str("local"), arg),
                            a(str("remote"), arg)
                        )
                    ),
                    b(str("protect-interface"),
                      interface_name
                    ),
                    a(str("action-priority"), arg),
                    a(str("remote-site-id"), arg),
                    a(str("target-attachment-identifier"), arg),
                    str("flow-label-transmit"),
                    str("flow-label-receive"),
                    b(str("encapsulation-type"),
                      (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
                    ),
                    str("ignore-encapsulation-mismatch"),
                    a(str("mtu"), arg),
                    str("ignore-mtu-mismatch"),
                    c(
                      str("control-word"),
                      str("no-control-word")
                    ),
                    str("pseudowire-status-tlv"),
                    b(str("oam"),
                        c(
                            a(str("ping-interval"), arg),
                            a(str("ping-multiplier"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("community"), arg),
                    b(a(str("static-mac"), arg),
                        c(
                            a(str("vlan-id"), arg)
                        )
                    ),
                    b(str("interface-mac-ip-limit"),
                        c(
                              arg
                        )
                    ),
                    str("no-mac-learning"),
                    str("mac-pinning"),
                    a(str("description"), quote | arg),
                    str("persistent-learning")
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    b(str("level"),
                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                    ),
                    a(str("flag"), enum(str("configuration") | str("routing-socket") | str("interface-device") | str("interface-logical") | str("interface-family") | str("bridging-domain") | str("bridge-interface") | str("learning-domain") | str("ipc") | str("mac-learning") | str("initialization") | str("flood-next-hop") | str("irb") | str("vpls-ping") | str("vpls-loop-prev") | str("storm-control") | str("unknown-unicast-forwarding") | str("vxlan") | str("all"))).as(:oneline)
                )
            ),
            b(str("voip"),
                c(
                    a(str("interface"), str("access-ports") | arg,
                        c(
                            a(str("vlan"), arg),
                            a(str("forwarding-class"), arg)
                        )
                    )
                )
            ),
            b(str("unknown-unicast-forwarding"),
                c(
                    b(a(str("vlan"), arg),
                        c(
                            b(str("interface"),
                              interface_name
                            )
                        )
                    )
                )
            ),
            b(a(str("authentication-whitelist"), arg),
                c(
                    a(str("vlan-assignment"), arg),
                    a(str("bridge-domain-assignment"), arg),
                    b(str("interface"),
                      interface_name
                    )
                )
            )
        )
    end

    rule(:juniper_routing_options) do
        c(
            b(str("source-routing"),
                c(
                    str("ip"),
                    str("ipv6")
                )
            ),
            str("l3vpn-composite-nexthop"),
            b(str("source-packet-routing"),
                c(
                    b(a(str("mapping-server-entry"), arg),
                        c(
                            b(a(str("prefix-segment"), arg),
                                c(
                                    a(str("index"), arg),
                                    str("attached"),
                                    str("domain-wide-flooding"),
                                    str("no-node-segment")
                                )
                            ),
                            b(a(str("prefix-segment-range"), arg),
                                c(
                                    b(str("start-prefix"),
                                      ipprefix
                                    ),
                                    a(str("start-index"), arg),
                                    a(str("size"), arg),
                                    str("attached"),
                                    str("domain-wide-flooding"),
                                    str("no-node-segment")
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("srlg"), arg),
                c(
                    a(str("srlg-value"), arg),
                    a(str("srlg-cost"), arg)
                )
            ),
            str("lsp-telemetry"),
            str("warm-standby"),
            str("nonstop-routing"),
            b(str("nonstop-routing-options"),
                c(
                    a(str("precision-timers-max-period"), arg)
                )
            ),
            a(str("nsr-phantom-holdtime"), arg),
            b(a(str("rib"), arg),
                c(
                    b(str("static"),
                        c(
                            b(a(str("route"), arg),
                                c(
                                    c(
                                      b(str("next-hop"),
                                        ipaddr_or_interface
                                      ),
                                      str("reject"),
                                      str("discard"),
                                      str("receive"),
                                      a(str("next-table"), arg)
                                    ),
                                    b(str("qualified-next-hop"),
                                      qualified_nh_obj
                                    ),
                                    a(str("backup-pe-group"), arg),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("version"),
                                              (str("0") | str("1") | str("automatic"))
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("minimum-transmit-interval"), arg),
                                            a(str("minimum-receive-interval"), arg),
                                            a(str("multiplier"), arg),
                                            c(
                                              str("no-adaptation")
                                            ),
                                            b(str("transmit-interval"),
                                                c(
                                                    a(str("minimum-interval"), arg),
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("detection-time"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("authentication"),
                                                c(
                                                    a(str("key-chain"), arg),
                                                    b(str("algorithm"),
                                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                    ),
                                                    str("loose-check")
                                                )
                                            ),
                                            b(str("neighbor"),
                                              ipaddr
                                            ),
                                            b(str("local-address"),
                                              ipaddr
                                            ),
                                            a(str("holddown-interval"), arg),
                                            a(str("minimum-receive-ttl"), arg)
                                        )
                                    ),
                                    str("retain"),
                                    str("no-retain"),
                                    str("install"),
                                    str("no-install"),
                                    str("readvertise"),
                                    str("no-readvertise"),
                                    str("resolve"),
                                    str("no-resolve"),
                                    str("longest-match"),
                                    str("no-longest-match"),
                                    c(
                                      str("active"),
                                      str("passive")
                                    ),
                                    b(str("metric"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric3"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric4"),
                                      rib_static_metric_type
                                    ),
                                    b(str("tag"),
                                      rib_static_metric_type
                                    ),
                                    b(str("tag2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("preference"),
                                      rib_static_metric_type
                                    ),
                                    b(str("preference2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("color"),
                                      rib_static_metric_type
                                    ),
                                    b(str("color2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("community"),
                                      community
                                    ),
                                    b(str("as-path"),
                                      c(
                                        a(str("path"), quote | arg),
                                            b(str("origin"),
                                              (str("igp") | str("egp") | str("incomplete"))
                                            ),
                                            str("atomic-aggregate"),
                                            b(str("aggregator"),
                                                ca(
                                                      ipv4addr
                                                )
                                            )
                                        )
                                    ),
                                    b(str("lsp-next-hop"),
                                      lsp_nh_obj
                                    ),
                                    b(str("static-lsp-next-hop"),
                                      lsp_nh_obj
                                    ),
                                    b(str("p2mp-lsp-next-hop"),
                                      lsp_nh_obj
                                    ),
                                    b(str("p2mp-ldp-next-hop"),
                                      p2mp_ldp_lsp_nh_obj
                                    )
                                )
                            ),
                            b(a(str("iso-route"), arg),
                                c(
                                    c(
                                      b(str("next-hop"),
                                        ipaddr_or_interface
                                      ),
                                      str("reject"),
                                      str("discard"),
                                      str("receive"),
                                      a(str("next-table"), arg)
                                    ),
                                    b(str("qualified-next-hop"),
                                      qualified_nh_obj
                                    ),
                                    a(str("backup-pe-group"), arg),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            b(str("version"),
                                              (str("0") | str("1") | str("automatic"))
                                            ),
                                            a(str("minimum-interval"), arg),
                                            a(str("minimum-transmit-interval"), arg),
                                            a(str("minimum-receive-interval"), arg),
                                            a(str("multiplier"), arg),
                                            c(
                                              str("no-adaptation")
                                            ),
                                            b(str("transmit-interval"),
                                                c(
                                                    a(str("minimum-interval"), arg),
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("detection-time"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ),
                                            b(str("authentication"),
                                                c(
                                                    a(str("key-chain"), arg),
                                                    b(str("algorithm"),
                                                      (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                                    ),
                                                    str("loose-check")
                                                )
                                            ),
                                            b(str("neighbor"),
                                              ipaddr
                                            ),
                                            b(str("local-address"),
                                              ipaddr
                                            ),
                                            a(str("holddown-interval"), arg),
                                            a(str("minimum-receive-ttl"), arg)
                                        )
                                    ),
                                    str("retain"),
                                    str("no-retain"),
                                    str("install"),
                                    str("no-install"),
                                    str("readvertise"),
                                    str("no-readvertise"),
                                    str("resolve"),
                                    str("no-resolve"),
                                    str("longest-match"),
                                    str("no-longest-match"),
                                    c(
                                      str("active"),
                                      str("passive")
                                    ),
                                    b(str("metric"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric3"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric4"),
                                      rib_static_metric_type
                                    ),
                                    b(str("tag"),
                                      rib_static_metric_type
                                    ),
                                    b(str("tag2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("preference"),
                                      rib_static_metric_type
                                    ),
                                    b(str("preference2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("color"),
                                      rib_static_metric_type
                                    ),
                                    b(str("color2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("community"),
                                      community
                                    ),
                                    b(str("as-path"),
                                      c(
                                        a(str("path"), quote | arg),
                                            b(str("origin"),
                                              (str("igp") | str("egp") | str("incomplete"))
                                            ),
                                            str("atomic-aggregate"),
                                            b(str("aggregator"),
                                                ca(
                                                      ipv4addr
                                                )
                                            )
                                        )
                                    ),
                                    b(str("lsp-next-hop"),
                                      lsp_nh_obj
                                    ),
                                    b(str("static-lsp-next-hop"),
                                      lsp_nh_obj
                                    ),
                                    b(str("p2mp-lsp-next-hop"),
                                      lsp_nh_obj
                                    ),
                                    b(str("p2mp-ldp-next-hop"),
                                      p2mp_ldp_lsp_nh_obj
                                    )
                                )
                            ),
                            a(str("rib-group"), arg),
                            b(str("defaults"),
                                c(
                                    str("retain"),
                                    str("no-retain"),
                                    str("install"),
                                    str("no-install"),
                                    str("readvertise"),
                                    str("no-readvertise"),
                                    str("resolve"),
                                    str("no-resolve"),
                                    str("longest-match"),
                                    str("no-longest-match"),
                                    c(
                                      str("active"),
                                      str("passive")
                                    ),
                                    b(str("metric"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric3"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric4"),
                                      rib_static_metric_type
                                    ),
                                    b(str("tag"),
                                      rib_static_metric_type
                                    ),
                                    b(str("tag2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("preference"),
                                      rib_static_metric_type
                                    ),
                                    b(str("preference2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("color"),
                                      rib_static_metric_type
                                    ),
                                    b(str("color2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("community"),
                                      community
                                    ),
                                    b(str("as-path"),
                                      c(
                                        a(str("path"), quote | arg),
                                            b(str("origin"),
                                              (str("igp") | str("egp") | str("incomplete"))
                                            ),
                                            str("atomic-aggregate"),
                                            b(str("aggregator"),
                                                ca(
                                                      ipv4addr
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("static-route"),
                                sc(
                                    b(str("bfd-admin-down"),
                                      (str("active") | str("passive"))
                                    )
                                )
                            ).as(:oneline),
                            b(a(str("route-target-filter"), arg),
                                c(
                                    b(str("neighbor"),
                                      ipaddr
                                    ),
                                    a(str("group"), arg),
                                    str("local")
                                )
                            )
                        )
                    ),
                    b(str("martians"),
                      martian_type
                    ),
                    b(str("aggregate"),
                      rib_aggregate_type
                    ),
                    b(str("generate"),
                      rib_aggregate_type
                    ),
                    c(
                      b(str("maximum-routes"),
                          sc(
                                arg,
                              c(
                                a(str("threshold"), arg),
                                str("log-only")
                              ),
                              a(str("log-interval"), arg)
                          )
                      ).as(:oneline),
                      b(str("maximum-paths"),
                          sc(
                                arg,
                              c(
                                a(str("threshold"), arg),
                                str("log-only")
                              ),
                              a(str("log-interval"), arg)
                          )
                      ).as(:oneline)
                    ),
                    b(str("maximum-prefixes"),
                        sc(
                              arg,
                            c(
                              a(str("threshold"), arg),
                              str("log-only")
                            ),
                            a(str("log-interval"), arg)
                        )
                    ).as(:oneline),
                    b(str("multipath"),
                        c(
                            b(str("vpn-unequal-cost"),
                                sc(
                                    str("equal-external-internal")
                                )
                            ).as(:oneline),
                            str("as-path-compare"),
                            str("preserve-nexthop-hierarchy")
                        )
                    ),
                    b(str("policy-multipath"),
                        c(
                            b(str("policy"),
                              policy_algebra
                            ),
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("route")),
                                        sc(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("protect"),
                        sc(
                            str("core")
                        )
                    ).as(:oneline),
                    b(str("access"),
                        c(
                            b(a(str("route"), arg),
                                c(
                                    b(str("next-hop"),
                                      ipaddr_or_interface
                                    ),
                                    b(str("qualified-next-hop"),
                                      qualified_nh_obj
                                    ),
                                    a(str("metric"), arg),
                                    a(str("preference"), arg),
                                    a(str("tag"), arg),
                                    a(str("tag2"), arg)
                                )
                            )
                        )
                    ),
                    b(str("access-internal"),
                        c(
                            b(a(str("route"), arg),
                                c(
                                    b(str("next-hop"),
                                      ipaddr_or_interface
                                    ),
                                    b(str("qualified-next-hop"),
                                      qualified_nh_obj
                                    )
                                )
                            )
                        )
                    ),
                    b(str("bgp-static"),
                        c(
                            b(a(str("route"), arg),
                                c(
                                    b(str("metric"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric3"),
                                      rib_static_metric_type
                                    ),
                                    b(str("metric4"),
                                      rib_static_metric_type
                                    ),
                                    b(str("tag"),
                                      rib_static_metric_type
                                    ),
                                    b(str("tag2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("preference"),
                                      rib_static_metric_type
                                    ),
                                    b(str("preference2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("color"),
                                      rib_static_metric_type
                                    ),
                                    b(str("color2"),
                                      rib_static_metric_type
                                    ),
                                    b(str("community"),
                                      community
                                    ),
                                    b(str("as-path"),
                                      c(
                                        a(str("path"), quote | arg),
                                            b(str("origin"),
                                              (str("igp") | str("egp") | str("incomplete"))
                                            ),
                                            str("atomic-aggregate"),
                                            b(str("aggregator"),
                                                ca(
                                                      ipv4addr
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("flow"),
                        c(
                            b(str("validation"),
                              flow_validation
                            ),
                            b(str("route"),
                              flow_route_inet6
                            ),
                            b(str("interface-group"),
                              flow_interface_group
                            ),
                            str("discard-action-for-unresolved-redir-addr")
                        )
                    ),
                    b(str("label"),
                        c(
                            b(str("allocation"),
                              policy_algebra
                            ),
                            b(str("substitution"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            b(str("static"),
                c(
                    b(a(str("route"), arg),
                        c(
                            c(
                              b(str("next-hop"),
                                ipaddr_or_interface
                              ),
                              str("reject"),
                              str("discard"),
                              str("receive"),
                              a(str("next-table"), arg)
                            ),
                            b(str("qualified-next-hop"),
                              qualified_nh_obj
                            ),
                            a(str("backup-pe-group"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("authentication"),
                                        c(
                                            a(str("key-chain"), arg),
                                            b(str("algorithm"),
                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                            ),
                                            str("loose-check")
                                        )
                                    ),
                                    b(str("neighbor"),
                                      ipaddr
                                    ),
                                    b(str("local-address"),
                                      ipaddr
                                    ),
                                    a(str("holddown-interval"), arg),
                                    a(str("minimum-receive-ttl"), arg)
                                )
                            ),
                            str("retain"),
                            str("no-retain"),
                            str("install"),
                            str("no-install"),
                            str("readvertise"),
                            str("no-readvertise"),
                            str("resolve"),
                            str("no-resolve"),
                            str("longest-match"),
                            str("no-longest-match"),
                            c(
                              str("active"),
                              str("passive")
                            ),
                            b(str("metric"),
                              rib_static_metric_type
                            ),
                            b(str("metric2"),
                              rib_static_metric_type
                            ),
                            b(str("metric3"),
                              rib_static_metric_type
                            ),
                            b(str("metric4"),
                              rib_static_metric_type
                            ),
                            b(str("tag"),
                              rib_static_metric_type
                            ),
                            b(str("tag2"),
                              rib_static_metric_type
                            ),
                            b(str("preference"),
                              rib_static_metric_type
                            ),
                            b(str("preference2"),
                              rib_static_metric_type
                            ),
                            b(str("color"),
                              rib_static_metric_type
                            ),
                            b(str("color2"),
                              rib_static_metric_type
                            ),
                            b(str("community"),
                              community
                            ),
                            b(str("as-path"),
                              c(
                                a(str("path"), quote | arg),
                                    b(str("origin"),
                                      (str("igp") | str("egp") | str("incomplete"))
                                    ),
                                    str("atomic-aggregate"),
                                    b(str("aggregator"),
                                        ca(
                                              ipv4addr
                                        )
                                    )
                                )
                            ),
                            b(str("lsp-next-hop"),
                              lsp_nh_obj
                            ),
                            b(str("static-lsp-next-hop"),
                              lsp_nh_obj
                            ),
                            b(str("p2mp-lsp-next-hop"),
                              lsp_nh_obj
                            ),
                            b(str("p2mp-ldp-next-hop"),
                              p2mp_ldp_lsp_nh_obj
                            )
                        )
                    ),
                    b(a(str("iso-route"), arg),
                        c(
                            c(
                              b(str("next-hop"),
                                ipaddr_or_interface
                              ),
                              str("reject"),
                              str("discard"),
                              str("receive"),
                              a(str("next-table"), arg)
                            ),
                            b(str("qualified-next-hop"),
                              qualified_nh_obj
                            ),
                            a(str("backup-pe-group"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("authentication"),
                                        c(
                                            a(str("key-chain"), arg),
                                            b(str("algorithm"),
                                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                                            ),
                                            str("loose-check")
                                        )
                                    ),
                                    b(str("neighbor"),
                                      ipaddr
                                    ),
                                    b(str("local-address"),
                                      ipaddr
                                    ),
                                    a(str("holddown-interval"), arg),
                                    a(str("minimum-receive-ttl"), arg)
                                )
                            ),
                            str("retain"),
                            str("no-retain"),
                            str("install"),
                            str("no-install"),
                            str("readvertise"),
                            str("no-readvertise"),
                            str("resolve"),
                            str("no-resolve"),
                            str("longest-match"),
                            str("no-longest-match"),
                            c(
                              str("active"),
                              str("passive")
                            ),
                            b(str("metric"),
                              rib_static_metric_type
                            ),
                            b(str("metric2"),
                              rib_static_metric_type
                            ),
                            b(str("metric3"),
                              rib_static_metric_type
                            ),
                            b(str("metric4"),
                              rib_static_metric_type
                            ),
                            b(str("tag"),
                              rib_static_metric_type
                            ),
                            b(str("tag2"),
                              rib_static_metric_type
                            ),
                            b(str("preference"),
                              rib_static_metric_type
                            ),
                            b(str("preference2"),
                              rib_static_metric_type
                            ),
                            b(str("color"),
                              rib_static_metric_type
                            ),
                            b(str("color2"),
                              rib_static_metric_type
                            ),
                            b(str("community"),
                              community
                            ),
                            b(str("as-path"),
                              c(
                                a(str("path"), quote | arg),
                                    b(str("origin"),
                                      (str("igp") | str("egp") | str("incomplete"))
                                    ),
                                    str("atomic-aggregate"),
                                    b(str("aggregator"),
                                        ca(
                                              ipv4addr
                                        )
                                    )
                                )
                            ),
                            b(str("lsp-next-hop"),
                              lsp_nh_obj
                            ),
                            b(str("static-lsp-next-hop"),
                              lsp_nh_obj
                            ),
                            b(str("p2mp-lsp-next-hop"),
                              lsp_nh_obj
                            ),
                            b(str("p2mp-ldp-next-hop"),
                              p2mp_ldp_lsp_nh_obj
                            )
                        )
                    ),
                    a(str("rib-group"), arg),
                    b(str("defaults"),
                        c(
                            str("retain"),
                            str("no-retain"),
                            str("install"),
                            str("no-install"),
                            str("readvertise"),
                            str("no-readvertise"),
                            str("resolve"),
                            str("no-resolve"),
                            str("longest-match"),
                            str("no-longest-match"),
                            c(
                              str("active"),
                              str("passive")
                            ),
                            b(str("metric"),
                              rib_static_metric_type
                            ),
                            b(str("metric2"),
                              rib_static_metric_type
                            ),
                            b(str("metric3"),
                              rib_static_metric_type
                            ),
                            b(str("metric4"),
                              rib_static_metric_type
                            ),
                            b(str("tag"),
                              rib_static_metric_type
                            ),
                            b(str("tag2"),
                              rib_static_metric_type
                            ),
                            b(str("preference"),
                              rib_static_metric_type
                            ),
                            b(str("preference2"),
                              rib_static_metric_type
                            ),
                            b(str("color"),
                              rib_static_metric_type
                            ),
                            b(str("color2"),
                              rib_static_metric_type
                            ),
                            b(str("community"),
                              community
                            ),
                            b(str("as-path"),
                              c(
                                a(str("path"), quote | arg),
                                    b(str("origin"),
                                      (str("igp") | str("egp") | str("incomplete"))
                                    ),
                                    str("atomic-aggregate"),
                                    b(str("aggregator"),
                                        ca(
                                              ipv4addr
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("static-route"),
                        sc(
                            b(str("bfd-admin-down"),
                              (str("active") | str("passive"))
                            )
                        )
                    ).as(:oneline),
                    b(a(str("route-target-filter"), arg),
                        c(
                            b(str("neighbor"),
                              ipaddr
                            ),
                            a(str("group"), arg),
                            str("local")
                        )
                    )
                )
            ),
            b(str("label"),
                c(
                    b(str("allocation"),
                      policy_algebra
                    ),
                    b(str("substitution"),
                      policy_algebra
                    )
                )
            ),
            b(str("access"),
                c(
                    b(a(str("route"), arg),
                        c(
                            b(str("next-hop"),
                              ipaddr_or_interface
                            ),
                            b(str("qualified-next-hop"),
                              qualified_nh_obj
                            ),
                            a(str("metric"), arg),
                            a(str("preference"), arg),
                            a(str("tag"), arg),
                            a(str("tag2"), arg)
                        )
                    )
                )
            ),
            b(str("access-internal"),
                c(
                    b(a(str("route"), arg),
                        c(
                            b(str("next-hop"),
                              ipaddr_or_interface
                            ),
                            b(str("qualified-next-hop"),
                              qualified_nh_obj
                            )
                        )
                    )
                )
            ),
            b(str("route-distinguisher-id"),
              ipv4addr
            ),
            b(a(str("interface"), arg),
                c(
                    a(str("arp-prefix-limit"), arg),
                    a(str("supplementary-blackout-timer"), arg),
                    c(
                      str("link-protection")
                    )
                )
            ),
            b(str("host-fast-reroute"),
                c(
                    a(str("global-arp-prefix-limit"), arg),
                    a(str("global-supplementary-blackout-timer"), arg)
                )
            ),
            b(str("backup-selection"),
                c(
                    b(a(str("destination"), arg),
                        c(
                            b(a(str("interface"), arg),
                                c(
                                    b(str("admin-group"),
                                        c(
                                            a(str("exclude"), arg),
                                            a(str("include-all"), arg),
                                            a(str("include-any"), arg),
                                            a(str("preference"), arg)
                                        )
                                    ),
                                    b(str("srlg"),
                                      (str("loose") | str("strict"))
                                    ),
                                    b(str("protection-type"),
                                      (str("link") | str("node") | str("node-link"))
                                    ),
                                    str("downstream-paths-only"),
                                    str("bandwidth-greater-equal-primary"),
                                    b(str("backup-neighbor"),
                                        c(
                                            b(str("exclude"),
                                              ipv4addr
                                            ),
                                            b(str("preference"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("node"),
                                        c(
                                            b(str("exclude"),
                                              ipv4addr
                                            ),
                                            b(str("preference"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("node-tag"),
                                        c(
                                            a(str("exclude"), arg),
                                            a(str("preference"), arg)
                                        )
                                    ),
                                    b(str("root-metric"),
                                      (str("lowest") | str("highest"))
                                    ),
                                    b(str("dest-metric"),
                                      (str("lowest") | str("highest"))
                                    ),
                                    b(str("metric-order"),
                                      (str("root") | str("dest"))
                                    ),
                                    b(str("evaluation-order"),
                                      (str("admin-group") | str("srlg") | str("bandwidth") | str("protection-type") | str("backup-neighbor") | str("node") | str("node-tag") | str("metric"))
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("multicast"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("parse") | str("config-internal") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("rpf"), arg),
                    b(a(str("scope"), arg),
                        c(
                            b(str("prefix"),
                              ipprefix
                            ),
                            b(str("interface"),
                              interface_name
                            )
                        )
                    ),
                    b(str("scope-policy"),
                      policy_algebra
                    ),
                    b(a(str("flow-map"), arg),
                        c(
                            b(str("policy"),
                              policy_algebra
                            ),
                            b(str("bandwidth"),
                                sc(
                                    arg,
                                    str("adaptive")
                                )
                            ).as(:oneline),
                            b(str("redundant-sources"),
                              ipaddr
                            ),
                            b(str("forwarding-cache"),
                                c(
                                    b(str("timeout"),
                                        sc(
                                            ca(
                                              b(str("never"),
                                                  c(
                                                      str("non-discard-entry-only")
                                                  )
                                              )
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("resolve-filter"),
                      policy_algebra
                    ),
                    b(str("ssm-groups"),
                      ipprefix
                    ),
                    str("asm-override-ssm"),
                    b(str("rpf-check-policy"),
                      policy_algebra
                    ),
                    b(str("pim-to-igmp-proxy"),
                        c(
                            b(str("upstream-interface"),
                              interface_name
                            )
                        )
                    ),
                    b(str("pim-to-mld-proxy"),
                        c(
                            b(str("upstream-interface"),
                              interface_name
                            )
                        )
                    ),
                    b(str("forwarding-cache"),
                        c(
                            str("allow-maximum"),
                            a(str("family"), enum(str("inet6") | str("inet")),
                                c(
                                    b(str("threshold"),
                                        c(
                                            a(str("suppress"), arg),
                                            a(str("reuse"), arg),
                                            a(str("mvpn-rpt-suppress"), arg),
                                            a(str("mvpn-rpt-reuse"), arg),
                                            a(str("log-warning"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("threshold"),
                                c(
                                    a(str("suppress"), arg),
                                    a(str("reuse"), arg),
                                    a(str("mvpn-rpt-suppress"), arg),
                                    a(str("mvpn-rpt-reuse"), arg),
                                    a(str("log-warning"), arg)
                                )
                            ),
                            a(str("timeout"), arg)
                        )
                    ),
                    b(str("interface"),
                      multicast_interface_options_type
                    ),
                    b(a(str("ssm-map"), arg),
                        c(
                            b(str("policy"),
                              policy_algebra
                            ),
                            b(str("source"),
                              ipaddr
                            )
                        )
                    ),
                    b(str("stream-protection"),
                        c(
                            str("mofrr-primary-path-selection-by-routing"),
                            str("mofrr-disjoint-upstream-only"),
                            str("mofrr-no-backup-join"),
                            str("mofrr-asm-starg"),
                            b(str("policy"),
                              policy_algebra
                            )
                        )
                    ),
                    b(a(str("backup-pe-group"), arg),
                        c(
                            b(str("backups"),
                              ipaddr
                            ),
                            b(str("local-address"),
                              ipaddr
                            )
                        )
                    ),
                    str("omit-wildcard-address"),
                    b(str("local-address"),
                      ipv4addr
                    )
                )
            ),
            b(str("dynamic-tunnels"),
                c(
                    b(a(str("tunnel-attributes"), arg),
                        c(
                            b(str("dynamic-tunnel-source-prefix"),
                              ipaddr
                            ),
                            b(str("dynamic-tunnel-type"),
                              (str("GRE") | str("V4oV6") | str("UDP") | str("BGP-SIGNAL"))
                            ),
                            a(str("dynamic-tunnel-mtu"), arg),
                            a(str("dynamic-tunnel-anchor-pfe"), arg),
                            b(str("dynamic-tunnel-anti-spoof"),
                              (str("on") | str("off"))
                            ),
                            b(str("dynamic-tunnel-reassembly"),
                              (str("on") | str("off"))
                            )
                        )
                    ),
                    b(a(str("forwarding-rib"), arg),
                        c(
                            b(str("inet-import"),
                              policy_algebra
                            )
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("kernel") | str("tunnel") | str("task") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("udp"),
                      (str("full-resolved-next-hop-based-tunnel"))
                    ),
                    b(str("v4ov6"),
                      (str("ipv6-anycast-source-duplication"))
                    ),
                    b(str("gre"),
                      (str("next-hop-based-tunnel"))
                    ),
                    b(str("signal-tunnel-preference"),
                        c(
                            a(str("gre"), arg),
                            a(str("udp"), arg)
                        )
                    ),
                      dynamic_tunnel_type
                )
            ),
            b(str("logical-system-mux"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("debug") | str("parse") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("rpm-tracking"),
                c(
                    b(a(str("route"), arg),
                        c(
                            b(str("next-hop"),
                              rpm_next_hop
                            ),
                            a(str("metric"), arg),
                            b(a(str("rpm-probe"), arg),
                                sc(
                                    a(str("rpm-test"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("validation"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("error") | str("packets") | str("keepalive") | str("update") | str("nsr-synchronization") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("notification-rib"), arg),
                    b(a(str("group"), arg),
                        c(
                            a(str("max-sessions"), arg),
                            b(a(str("session"), arg),
                                c(
                                    b(str("traceoptions"),
                                        c(
                                            b(str("file"),
                                                sc(
                                                      arg,
                                                    str("replace"),
                                                    a(str("size"), arg),
                                                    a(str("files"), arg),
                                                    str("no-stamp"),
                                                    str("world-readable"),
                                                    str("no-world-readable")
                                                )
                                            ).as(:oneline),
                                            a(str("flag"), enum(str("error") | str("packets") | str("keepalive") | str("update") | str("state") | str("task") | str("timer") | str("all")),
                                                sc(
                                                    str("send"),
                                                    str("receive"),
                                                    str("detail"),
                                                    str("disable")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    a(str("refresh-time"), arg),
                                    a(str("hold-time"), arg),
                                    a(str("record-lifetime"), arg),
                                    a(str("preference"), arg),
                                    a(str("port"), arg),
                                    b(str("local-address"),
                                      ipaddr
                                    )
                                )
                            )
                        )
                    ),
                    b(str("static"),
                        c(
                            b(a(str("record"), arg),
                                c(
                                    b(a(str("maximum-length"), arg),
                                        c(
                                            b(a(str("origin-autonomous-system"), arg),
                                                c(
                                                    b(str("validation-state"),
                                                      (str("invalid") | str("valid"))
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("options"),
                c(
                    str("no-send"),
                    str("no-resolve"),
                    b(str("syslog"),
                        c(
                            b(str("level"),
                                sc(
                                    str("emergency"),
                                    str("alert"),
                                    str("critical"),
                                    str("error"),
                                    str("warning"),
                                    str("notice"),
                                    str("info"),
                                    str("debug")
                                )
                            ).as(:oneline),
                            b(str("upto"),
                              (str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("debug"))
                            )
                        )
                    ),
                    a(str("mark"), arg)
                )
            ),
            b(str("forwarding-table"),
              forwarding_table_type
            ),
            b(str("resolution"),
                c(
                    b(str("tracefilter"),
                      policy_algebra
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("event") | str("flash") | str("kernel") | str("indirect") | str("task") | str("igp-frr") | str("igp-frr-extensive") | str("tunnel") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    str("preserve-nexthop-hierarchy"),
                    str("no-preserve-nexthop-hierarchy"),
                    b(a(str("rib"), arg),
                        c(
                            a(str("resolution-family"), arg),
                            a(str("resolution-ribs"), arg),
                            a(str("inet-resolution-ribs"), arg),
                            a(str("inet6-resolution-ribs"), arg),
                            a(str("iso-resolution-ribs"), arg),
                            b(str("import"),
                              policy_algebra
                            ),
                            b(str("inet-import"),
                              policy_algebra
                            ),
                            b(str("inet6-import"),
                              policy_algebra
                            ),
                            b(str("iso-import"),
                              policy_algebra
                            ),
                            b(str("inetcolor-import"),
                              policy_algebra
                            ),
                            b(str("inet6color-import"),
                              policy_algebra
                            )
                        )
                    ),
                    str("prefer-recursive-primary-path"),
                    str("no-prefer-recursive-primary-path")
                )
            ),
            b(str("interface-routes"),
                c(
                    b(str("rib-group"),
                      rib_group_type
                    ),
                    a(str("family"), enum(str("inet6") | str("inet")),
                        c(
                            b(str("import"),
                              policy_algebra
                            ),
                            b(str("export"),
                                c(
                                    str("point-to-point"),
                                    str("lan")
                                )
                            )
                        )
                    )
                )
            ),
            str("loopback-strict-disable"),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("parse") | str("regex-parse") | str("config-internal") | str("nsr-synchronization") | str("condition-manager") | str("graceful-restart") | str("session") | str("hfrr-fsm") | str("hfrr-route") | str("statistics-id-group") | str("route-record") | str("jvision-lsp") | str("dyn-nh-template") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                        sc(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("topologies"),
                c(
                    a(str("family"), enum(str("inet6") | str("inet")),
                        c(
                            b(a(str("topology"), arg),
                                c(
                                    a(str("table-id"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("router-id"),
              ipv4addr
            ),
            b(str("autonomous-system"),
                sc(
                    arg,
                    a(str("loops"), arg),
                    str("asdot-notation"),
                    b(str("independent-domain"),
                        sc(
                            str("no-attrset").as(:oneline)
                        )
                    ).as(:oneline)
                )
            ).as(:oneline),
            b(str("confederation"),
                sc(
                    arg,
                    a(str("members"), any)
                )
            ).as(:oneline),
            b(str("graceful-restart"),
                c(
                      (str("disable")),
                    a(str("restart-duration"), arg)
                )
            ),
            b(str("flow"),
                c(
                    str("firewall-install-disable"),
                    b(str("validation"),
                      flow_validation
                    ),
                    b(str("interface-group"),
                      flow_interface_group
                    ),
                    b(str("route"),
                      flow_route_inet
                    ),
                    b(str("term-order"),
                      (str("legacy") | str("standard"))
                    ),
                    str("discard-action-for-unresolved-redir-addr")
                )
            ),
            str("no-soft-core"),
            a(str("med-igp-update-interval"), arg),
            b(str("bmp"),
                c(
                    a(str("authentication-key"), arg),
                    b(str("authentication-algorithm"),
                      (str("md5") | str("hmac-sha-1-96") | str("aes-128-cmac-96"))
                    ),
                    a(str("authentication-key-chain"), arg),
                    b(str("hold-down"),
                        sc(
                              arg,
                            a(str("flaps"), arg),
                            a(str("period"), arg)
                        )
                    ).as(:oneline),
                    a(str("initiation-message"), arg),
                    b(str("local-address"),
                      ipaddr
                    ),
                    a(str("local-port"), arg),
                    b(str("connection-mode"),
                      (str("active") | str("passive"))
                    ),
                    b(str("priority"),
                      (str("low") | str("medium") | str("high"))
                    ),
                    b(str("monitor"),
                      (str("enable") | str("disable"))
                    ),
                    b(str("route-monitoring"),
                        c(
                            str("none"),
                            str("loc-rib"),
                            b(str("pre-policy"),
                                sc(
                                    str("exclude-non-feasible")
                                )
                            ).as(:oneline),
                            b(str("post-policy"),
                                sc(
                                    str("exclude-non-eligible")
                                )
                            ).as(:oneline),
                            b(str("rib-out"),
                                sc(
                                    str("pre-policy"),
                                    str("post-policy")
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("max-loc-rib-buffer-count"), arg),
                    b(str("station-address"),
                      ipaddr
                    ),
                    b(str("routing-instance"),
                      (str("default") | arg)
                    ),
                    a(str("station-port"), arg),
                    a(str("statistics-timeout"), arg),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("packets") | str("up") | str("down") | str("statistics") | str("route-monitoring") | str("event") | str("error") | str("write") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("station"), arg),
                        c(
                            a(str("authentication-key"), arg),
                            b(str("authentication-algorithm"),
                              (str("md5") | str("hmac-sha-1-96") | str("aes-128-cmac-96"))
                            ),
                            a(str("authentication-key-chain"), arg),
                            b(str("hold-down"),
                                sc(
                                      arg,
                                    a(str("flaps"), arg),
                                    a(str("period"), arg)
                                )
                            ).as(:oneline),
                            a(str("initiation-message"), arg),
                            b(str("local-address"),
                              ipaddr
                            ),
                            a(str("local-port"), arg),
                            b(str("connection-mode"),
                              (str("active") | str("passive"))
                            ),
                            b(str("priority"),
                              (str("low") | str("medium") | str("high"))
                            ),
                            b(str("monitor"),
                              (str("enable") | str("disable"))
                            ),
                            b(str("route-monitoring"),
                                c(
                                    str("none"),
                                    str("loc-rib"),
                                    b(str("pre-policy"),
                                        sc(
                                            str("exclude-non-feasible")
                                        )
                                    ).as(:oneline),
                                    b(str("post-policy"),
                                        sc(
                                            str("exclude-non-eligible")
                                        )
                                    ).as(:oneline),
                                    b(str("rib-out"),
                                        sc(
                                            str("pre-policy"),
                                            str("post-policy")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            a(str("max-loc-rib-buffer-count"), arg),
                            b(str("station-address"),
                              ipaddr
                            ),
                            b(str("routing-instance"),
                              (str("default") | arg)
                            ),
                            a(str("station-port"), arg),
                            a(str("statistics-timeout"), arg),
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                        sc(
                                              arg,
                                            str("replace"),
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("no-stamp"),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("packets") | str("up") | str("down") | str("statistics") | str("route-monitoring") | str("event") | str("error") | str("write") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                        sc(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            str("bgp-orf-cisco-mode"),
            b(str("ppm"),
                c(
                    str("delegate-processing"),
                    str("no-delegate-processing"),
                    str("inline-processing-enable"),
                    str("inline-ae-processing-enable"),
                    a(str("redistribution-timer"), arg)
                )
            ),
            str("no-bfd-triggered-local-repair"),
            b(str("auto-bandwidth"),
                c(
                    b(a(str("template"), arg),
                        c(
                            a(str("adjust-interval"), arg),
                            a(str("adjust-threshold"), arg),
                            a(str("statistic-collection-interval"), arg),
                            a(str("auto-bandwidth-subscription"), arg)
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("all") | str("timer") | str("state")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("admin-groups-extended-range"),
                c(
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(a(str("admin-groups-extended"), arg),
                c(
                    a(str("group-value"), arg)
                )
            ),
            str("enable-sensors"),
            b(str("martians"),
              martian_type
            ),
            b(str("aggregate"),
              rib_aggregate_type
            ),
            b(str("generate"),
              rib_aggregate_type
            ),
            c(
              b(str("maximum-routes"),
                  sc(
                        arg,
                      c(
                        a(str("threshold"), arg),
                        str("log-only")
                      ),
                      a(str("log-interval"), arg)
                  )
              ).as(:oneline),
              b(str("maximum-paths"),
                  sc(
                        arg,
                      c(
                        a(str("threshold"), arg),
                        str("log-only")
                      ),
                      a(str("log-interval"), arg)
                  )
              ).as(:oneline)
            ),
            b(str("maximum-prefixes"),
                sc(
                      arg,
                    c(
                      a(str("threshold"), arg),
                      str("log-only")
                    ),
                    a(str("log-interval"), arg)
                )
            ).as(:oneline),
            b(str("multipath"),
                c(
                    b(str("vpn-unequal-cost"),
                        sc(
                            str("equal-external-internal")
                        )
                    ).as(:oneline),
                    str("as-path-compare"),
                    str("preserve-nexthop-hierarchy")
                )
            ),
            b(str("policy-multipath"),
                c(
                    b(str("policy"),
                      policy_algebra
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("route")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("protect"),
                sc(
                    str("core")
                )
            ).as(:oneline),
            b(str("bgp-static"),
                c(
                    b(a(str("route"), arg),
                        c(
                            b(str("metric"),
                              rib_static_metric_type
                            ),
                            b(str("metric2"),
                              rib_static_metric_type
                            ),
                            b(str("metric3"),
                              rib_static_metric_type
                            ),
                            b(str("metric4"),
                              rib_static_metric_type
                            ),
                            b(str("tag"),
                              rib_static_metric_type
                            ),
                            b(str("tag2"),
                              rib_static_metric_type
                            ),
                            b(str("preference"),
                              rib_static_metric_type
                            ),
                            b(str("preference2"),
                              rib_static_metric_type
                            ),
                            b(str("color"),
                              rib_static_metric_type
                            ),
                            b(str("color2"),
                              rib_static_metric_type
                            ),
                            b(str("community"),
                              community
                            ),
                            b(str("as-path"),
                              c(
                                a(str("path"), quote | arg),
                                    b(str("origin"),
                                      (str("igp") | str("egp") | str("incomplete"))
                                    ),
                                    str("atomic-aggregate"),
                                    b(str("aggregator"),
                                        ca(
                                              ipv4addr
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("rib-groups"),
              rpd_rib_group_type
            ),
            str("route-record"),
            b(str("localized-fib"),
                c(
                    a(str("fpc-slot"), arg)
                )
            ),
            b(str("instance-import"),
              policy_algebra
            ),
            b(str("instance-export"),
              policy_algebra
            ),
            b(str("auto-export"),
                c(
                      (str("disable")),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("export") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")),
                                sc(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                              export_af_obj
                            ),
                            b(str("inet6"),
                              export_af_obj
                            ),
                            b(str("iso"),
                              export_af_obj
                            )
                        )
                    )
                )
            ),
            b(str("fate-sharing"),
                c(
                    b(a(str("group"), arg),
                        c(
                            a(str("cost"), arg),
                            str("use-for-post-convergence-lfa"),
                            b(str("from"),
                              fate_sharing_links
                            )
                        )
                    )
                )
            ),
            b(str("programmable-rpd"),
              programmable_rpd_type
            )
        )
    end

    rule(:dynamic_tunnel_type) do
      b(arg.as(:arg),
        c(
            b(str("source-address"),
              ipaddr
            ),
            c(
              b(a(str("rsvp-te"), arg),
                  c(
                      b(str("label-switched-path-template"),
                          c(
                              ca(
                                str("default-template")
                              )
                          )
                      ),
                      b(str("destination-networks"),
                        network_type
                      )
                  )
              ),
              b(str("spring-te"),
                  c(
                      b(str("source-routing-path-template"),
                        spring_te_template_map
                      ),
                      b(str("destination-networks"),
                        network_type
                      )
                  )
              ),
              str("gre"),
              str("udp"),
              str("bgp-signal")
            ),
            b(str("destination-networks"),
              network_type
            )
        )
      )
    end

    rule(:export_af_obj) do
        c(
              (str("disable")),
            b(str("unicast"),
              export_subaf_obj
            ),
            b(str("multicast"),
              export_subaf_obj
            ),
            b(str("flow"),
              export_subaf_obj
            )
        )
    end

    rule(:export_subaf_obj) do
        c(
              (str("disable")),
            a(str("rib-group"), arg)
        )
    end

    rule(:fate_sharing_links) do
      b(arg.as(:arg),
        c(
            b(str("to"),
              ipv4addr
            )
        )
      ).as(:oneline)
    end

    rule(:flow_route_inet) do
      b(arg.as(:arg),
        c(
            str("no-install"),
            b(str("match"),
              flow_route_qualifier_inet
            ),
            b(str("then"),
              flow_route_op
            )
        )
      )
    end

    rule(:flow_route_qualifier_inet) do
        c(
            b(str("protocol"),
              (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
            ),
            b(str("port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("destination-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("source-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("tcp-flags"),
              (str("fin") | str("syn") | str("rst") | str("push") | str("ack") | str("urgent") | arg)
            ),
            b(str("packet-length"),
              policy_algebra
            ),
            b(str("dscp"),
              policy_algebra
            ),
            b(str("fragment"),
              (str("dont-fragment") | str("not-a-fragment") | str("is-fragment") | str("first-fragment") | str("last-fragment"))
            ),
            b(str("destination"),
              ipv4prefix
            ),
            b(str("source"),
              ipv4prefix
            ),
            b(str("icmp-code"),
              (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
            ),
            b(str("icmp-type"),
              (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
            )
        )
    end

    rule(:juniper_sampling_options) do
        c(
              (str("disable")),
            b(str("traceoptions"),
              sampling_traceoptions_type
            ),
            str("sample-once"),
            str("pre-rewrite-tos"),
            b(str("input"),
              sampling_input_type
            ),
            b(str("output"),
              sampling_output_type
            ),
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                              (str("disable")),
                            b(str("input"),
                              sampling_family_input_type
                            ),
                            b(str("output"),
                              sampling_instance_inet_global_output_type
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                              (str("disable")),
                            b(str("input"),
                              sampling_family_input_type
                            ),
                            b(str("output"),
                              sampling_family_inet6_output_type
                            )
                        )
                    ),
                    b(str("mpls"),
                        c(
                              (str("disable")),
                            b(str("input"),
                              sampling_family_input_type
                            ),
                            b(str("output"),
                              sampling_global_mpls_output_type
                            )
                        )
                    )
                )
            ),
            b(a(str("instance"), arg),
                c(
                      (str("disable")),
                    b(str("input"),
                      sampling_instance_input_type
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                      (str("disable")),
                                    b(str("input"),
                                      sampling_family_input_type
                                    ),
                                    b(str("output"),
                                      sampling_instance_inet_output_type
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                      (str("disable")),
                                    b(str("input"),
                                      sampling_family_input_type
                                    ),
                                    b(str("output"),
                                      sampling_instance_inet6_output_type
                                    )
                                )
                            ),
                            b(str("mpls"),
                                c(
                                      (str("disable")),
                                    b(str("input"),
                                      sampling_family_input_type
                                    ),
                                    b(str("output"),
                                      sampling_instance_mpls_output_type
                                    )
                                )
                            ),
                            b(str("vpls"),
                                c(
                                      (str("disable")),
                                    b(str("input"),
                                      sampling_family_input_type
                                    ),
                                    b(str("output"),
                                      sampling_instance_vpls_output_type
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                      (str("disable")),
                                    b(str("input"),
                                      sampling_family_input_type
                                    ),
                                    b(str("output"),
                                      sampling_instance_bridge_output_type
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("jflow-service"),
                c(
                    b(str("traceoptions"),
                      jflow_service_traceoptions
                    )
                )
            ),
            b(str("route-record"),
                c(
                    b(str("traceoptions"),
                      route_record_traceoptions
                    )
                )
            )
        )
    end

    rule(:jflow_service_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("parse") | str("rtsock") | str("sm") | str("all"))).as(:oneline)
        )
    end

    rule(:juniper_services_captive_portal) do
        c(
            a(str("authentication-profile-name"), arg),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("dot1x-debug") | str("parse") | str("esw-if") | str("config-internal") | str("normal") | str("general") | str("state") | str("task") | str("timer") | str("all") | str("dot1x-ipc") | str("dot1x-event")),
                        sc(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("interface"), str("all") | arg,
                c(
                    b(str("supplicant"),
                      (str("single") | str("single-secure") | str("multiple"))
                    ),
                    a(str("retries"), arg),
                    a(str("quiet-period"), arg),
                    a(str("server-timeout"), arg),
                    a(str("session-expiry"), arg),
                    a(str("user-keepalive"), arg)
                )
            ),
            b(str("secure-authentication"),
              (str("https") | str("http"))
            ),
            b(str("custom-options"),
                c(
                    a(str("header-logo"), arg),
                    a(str("header-bgcolor"), arg),
                    a(str("header-text-color"), arg),
                    a(str("header-message"), arg),
                    a(str("banner-message"), arg),
                    a(str("form-header-message"), arg),
                    a(str("form-header-bgcolor"), arg),
                    a(str("form-header-text-color"), arg),
                    a(str("form-submit-label"), arg),
                    a(str("form-reset-label"), arg),
                    a(str("footer-message"), arg),
                    a(str("footer-bgcolor"), arg),
                    a(str("footer-text-color"), arg),
                    a(str("post-authentication-url"), arg)
                )
            )
        )
    end

    rule(:juniper_system) do
        c(
            a(str("host-name"), arg),
            b(str("root-authentication"),
              authentication_object
            ),
            b(str("commit"),
                c(
                    b(str("commit-synchronize-server"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            str("microsecond-stamp")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("ephemeral-commit") | str("operational-command") | str("debug") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    str("persist-groups-inheritance"),
                    str("no-persist-groups-inheritance"),
                    b(str("server"),
                        c(
                            a(str("maximum-aggregate-pool"), arg),
                            a(str("maximum-entries"), arg),
                            a(str("commit-interval"), arg),
                            a(str("retry-attempts"), arg),
                            a(str("retry-interval"), arg),
                            a(str("days-to-keep-error-logs"), arg),
                            a(str("redirect-completion-status"), arg),
                            b(a(str("commit-schedule-profile"), arg),
                                c(
                                    a(str("start-time"), arg),
                                    a(str("end-time"), arg),
                                    str("interruptible"),
                                    b(str("load-average"),
                                      unsigned_float
                                    )
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            str("microsecond-stamp")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("all") | str("commit-server") | str("batch") | str("configuration"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    str("fast-synchronize"),
                    str("synchronize"),
                    str("delta-export"),
                    b(str("notification"),
                        c(
                            b(str("configuration-diff-format"),
                              (str("xml") | str("json"))
                            )
                        )
                    ),
                    str("peers-synchronize"),
                    b(str("peers"),
                      peers_type
                    )
                )
            ),
            b(str("configuration-database"),
                c(
                    b(str("ephemeral"),
                        c(
                            a(str("instance"), arg),
                            str("ignore-ephemeral-default"),
                            str("allow-commit-synchronize-with-gres")
                        )
                    ),
                    b(str("virtual-memory-mapping"),
                        c(
                            b(a(str("process"), arg),
                                c(
                                    a(str("fixed-size"), arg),
                                    a(str("page-pooling-size"), arg),
                                    str("page-leak-debug")
                                )
                            ),
                            b(str("process-set"),
                                c(
                                    b(str("subscriber-management"),
                                        c(
                                            a(str("fixed-size"), arg),
                                            a(str("page-pooling-size"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("extend-size"),
                    b(str("resize"),
                        c(
                            a(str("database-size-on-disk"), arg),
                            a(str("database-size-diff"), arg)
                        )
                    ),
                    a(str("max-db-size"), arg)
                )
            ),
            b(str("scripts"),
              scripts_type
            ),
            b(str("login"),
                c(
                    b(str("retry-options"),
                        c(
                            a(str("tries-before-disconnect"), arg),
                            a(str("backoff-threshold"), arg),
                            a(str("backoff-factor"), arg),
                            a(str("minimum-time"), arg),
                            a(str("maximum-time"), arg),
                            a(str("lockout-period"), arg)
                        )
                    ),
                    a(str("idle-timeout"), arg),
                    b(str("class"),
                      login_class_object
                    ),
                    b(str("user"),
                      login_user_object
                    ),
                    b(str("password"),
                        c(
                            a(str("minimum-character-changes"), arg),
                            a(str("minimum-reuse"), arg),
                            a(str("maximum-lifetime"), arg),
                            a(str("minimum-lifetime"), arg),
                            a(str("minimum-length"), arg),
                            a(str("maximum-length"), arg),
                            b(str("change-type"),
                              (str("character-sets") | str("set-transitions"))
                            ),
                            a(str("minimum-changes"), arg),
                            a(str("minimum-numerics"), arg),
                            a(str("minimum-upper-cases"), arg),
                            a(str("minimum-lower-cases"), arg),
                            a(str("minimum-punctuations"), arg),
                            b(str("format"),
                              (str("sha1") | str("sha256") | str("sha512") | str("md5") | str("des"))
                            )
                        )
                    ),
                    b(str("deny-sources"),
                        c(
                            b(str("address"),
                              ipprefix_optional
                            )
                        )
                    ),
                    a(str("announcement"), arg),
                    a(str("message"), quote | arg)
                )
            ),
            str("autoinstallation"),
            b(str("services"),
                c(
                    str("netproxy"),
                    b(str("finger"),
                        c(
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg)
                        )
                    ),
                    b(str("ftp"),
                        c(
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg),
                            b(str("authentication-order"),
                              (str("radius") | str("tacplus") | str("password"))
                            )
                        )
                    ),
                    b(str("ssh"),
                        c(
                            b(str("authentication-order"),
                              (str("radius") | str("tacplus") | str("password"))
                            ),
                            b(str("root-login"),
                              (str("allow") | str("deny") | str("deny-password"))
                            ),
                            str("no-challenge-response"),
                            str("no-password-authentication"),
                            str("no-passwords"),
                            str("no-public-keys"),
                            c(
                              str("tcp-forwarding"),
                              str("no-tcp-forwarding")
                            ),
                            b(str("protocol-version"),
                              (str("v2"))
                            ),
                            a(str("max-sessions-per-connection"), arg),
                            a(str("max-pre-authentication-packets"), arg),
                            str("sftp-server"),
                            b(str("ciphers"),
                              (str("3des-cbc") | str("aes128-cbc") | str("aes192-cbc") | str("aes256-cbc") | str("aes128-ctr") | str("aes192-ctr") | str("aes256-ctr") | str("aes128-gcm@openssh.com") | str("aes256-gcm@openssh.com") | str("chacha20-poly1305@openssh.com") | str("arcfour128") | str("arcfour256") | str("arcfour") | str("blowfish-cbc") | str("cast128-cbc"))
                            ),
                            b(str("macs"),
                              (str("hmac-md5") | str("hmac-md5-etm@openssh.com") | str("hmac-sha1") | str("hmac-sha1-etm@openssh.com") | str("umac-64@openssh.com") | str("umac-128@openssh.com") | str("umac-64-etm@openssh.com") | str("umac-128-etm@openssh.com") | str("hmac-sha2-256") | str("hmac-sha2-256-etm@openssh.com") | str("hmac-sha2-256-96") | str("hmac-sha2-512") | str("hmac-sha2-512-etm@openssh.com") | str("hmac-sha2-512-96") | str("hmac-ripemd160") | str("hmac-ripemd160-etm@openssh.com") | str("hmac-sha1-96") | str("hmac-sha1-96-etm@openssh.com") | str("hmac-md5-96") | str("hmac-md5-96-etm@openssh.com"))
                            ),
                            b(str("key-exchange"),
                              (str("curve25519-sha256") | str("ecdh-sha2-nistp256") | str("ecdh-sha2-nistp384") | str("ecdh-sha2-nistp521") | str("group-exchange-sha2") | str("group-exchange-sha1") | str("dh-group14-sha1") | str("dh-group1-sha1"))
                            ),
                            a(str("client-alive-count-max"), arg),
                            a(str("client-alive-interval"), arg),
                            b(str("hostkey-algorithm"),
                                c(
                                    c(
                                      str("no-ssh-dss"),
                                      b(str("ssh-dss"),
                                          c(
                                              c(
                                                str("allow"),
                                                str("deny")
                                              )
                                          )
                                      )
                                    ),
                                    c(
                                      str("no-ssh-rsa"),
                                      b(str("ssh-rsa"),
                                          c(
                                              c(
                                                str("allow"),
                                                str("deny")
                                              )
                                          )
                                      )
                                    ),
                                    c(
                                      str("no-ssh-ecdsa"),
                                      b(str("ssh-ecdsa"),
                                          c(
                                              c(
                                                str("allow"),
                                                str("deny")
                                              )
                                          )
                                      )
                                    ),
                                    c(
                                      str("no-ssh-ed25519"),
                                      str("ssh-ed25519")
                                    )
                                )
                            ),
                            b(str("fingerprint-hash"),
                              (str("sha2-256") | str("md5"))
                            ),
                            a(str("authorized-keys-command"), arg),
                            a(str("authorized-keys-command-user"), arg),
                            b(str("rekey"),
                                c(
                                    a(str("data-limit"), arg),
                                    a(str("time-limit"), arg)
                                )
                            ),
                            a(str("port"), arg),
                            str("log-key-changes"),
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg)
                        )
                    ),
                    b(str("telnet"),
                        c(
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg),
                            b(str("authentication-order"),
                              (str("radius") | str("tacplus") | str("password"))
                            )
                        )
                    ),
                    b(str("xnm-clear-text"),
                        c(
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg)
                        )
                    ),
                    b(str("xnm-ssl"),
                        c(
                            a(str("local-certificate"), arg),
                            str("ssl-renegotiation"),
                            str("no-ssl-renegotiation"),
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg)
                        )
                    ),
                    b(str("jeb"),
                        c(
                            a(str("port"), arg),
                            b(str("rbg"),
                              (str("default-rng") | str("hmac-drbg") | str("jrbc"))
                            ),
                            a(str("max-seed-size"), arg),
                            b(str("tls"),
                                c(
                                    a(str("cert-bundle"), arg),
                                    a(str("certificate"), arg),
                                    a(str("key"), arg)
                                )
                            )
                        )
                    ),
                    b(str("extension-service"),
                        c(
                            b(str("request-response"),
                                c(
                                    b(str("grpc"),
                                        c(
                                            c(
                                              b(str("ssl"),
                                                  c(
                                                      b(str("address"),
                                                        ipaddr
                                                      ),
                                                      a(str("port"), arg),
                                                      a(str("local-certificate"), arg),
                                                      b(str("mutual-authentication"),
                                                          c(
                                                              a(str("certificate-authority"), arg),
                                                              b(str("client-certificate-request"),
                                                                (str("no-certificate") | str("request-certificate") | str("request-certificate-and-verify") | str("require-certificate") | str("require-certificate-and-verify"))
                                                              )
                                                          )
                                                      )
                                                  )
                                              )
                                            ),
                                            a(str("max-connections"), arg),
                                            a(str("routing-instance"), arg),
                                            b(str("clear-text"),
                                                c(
                                                    a(str("address"), ipaddr),
                                                    a(str("port"), arg)
                                                )
                                            ),
                                            str("skip-authentication")
                                        )
                                    )
                                )
                            ),
                            b(str("notification"),
                                c(
                                    a(str("port"), arg),
                                    a(str("max-connections"), arg),
                                    a(str("broker-socket-send-buffer-size"), arg),
                                    b(str("allow-clients"),
                                        c(
                                            b(str("address"),
                                              ipprefix_optional
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                        sc(
                                            c(
                                              str("error")
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("timer") | str("timeouts") | str("routing-socket") | str("general") | str("config") | str("grpc") | str("libgrpc-debug") | str("libgrpc-errors") | str("libgrpc-info") | str("notification") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("netconf"),
                        c(
                            b(str("ssh"),
                                c(
                                    a(str("connection-limit"), arg),
                                    a(str("rate-limit"), arg),
                                    a(str("port"), arg)
                                )
                            ),
                            b(str("unified"),
                                c(
                                    str("unhide")
                                )
                            ),
                            str("rfc-compliant"),
                            str("yang-compliant"),
                            b(str("yang-modules"),
                                c(
                                    str("device-specific"),
                                    str("emit-extensions")
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("all") | str("incoming") | str("outgoing") | str("debug"))).as(:oneline),
                                    str("on-demand")
                                )
                            ),
                            b(str("notification"),
                                c(
                                    str("interleave")
                                )
                            )
                        )
                    ),
                    b(str("tftp-server"),
                        c(
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg)
                        )
                    ),
                    b(str("flow-tap-dtcp"),
                        c(
                            b(str("ssh"),
                                c(
                                    a(str("connection-limit"), arg),
                                    a(str("rate-limit"), arg)
                                )
                            )
                        )
                    ),
                    str("dtcp-only"),
                    b(str("reverse"),
                        c(
                            b(str("telnet"),
                                c(
                                    a(str("port"), arg)
                                )
                            ),
                            b(str("ssh"),
                                c(
                                    a(str("port"), arg)
                                )
                            )
                        )
                    ),
                    b(str("dns"),
                        c(
                            a(str("max-cache-ttl"), arg),
                            a(str("max-ncache-ttl"), arg),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    ).as(:oneline),
                                    a(str("debug-level"), arg),
                                    a(str("category"), str("default") | str("general") | str("database") | str("security") | str("config") | str("resolver") | str("xfer-in") | str("xfer-out") | str("notify") | str("client") | str("unmatched") | str("network") | str("update") | str("update-security") | str("queries") | str("dispatch") | str("dnssec") | str("lame-servers") | str("delegation-only") | str("edns-disabled")).as(:oneline)
                                )
                            ),
                            a(str("forwarders"), arg),
                            b(str("dnssec"),
                                c(
                                    str("disable"),
                                    b(str("trusted-keys"),
                                        c(
                                            a(str("key"), arg)
                                        )
                                    ),
                                    b(str("dlv"),
                                        s(
                                          a(str("domain"), arg),
                                          a(str("trusted-anchor"), arg)
                                        )
                                    ).as(:oneline),
                                    a(str("secure-domains"), arg)
                                )
                            )
                        )
                    ),
                    b(str("rest"),
                        c(
                            b(str("http"),
                                c(
                                    a(str("port"), arg),
                                    b(str("addresses"),
                                      ipv4addr
                                    )
                                )
                            ),
                            b(str("https"),
                                c(
                                    a(str("port"), arg),
                                    b(str("addresses"),
                                      ipv4addr
                                    ),
                                    a(str("server-certificate"), arg),
                                    b(str("cipher-list"),
                                      (str("rsa-with-rc4-128-md5") | str("rsa-with-rc4-128-sha") | str("rsa-with-3des-ede-cbc-sha") | str("dhe-rsa-with-3des-ede-cbc-sha") | str("rsa-with-aes-128-cbc-sha") | str("dhe-rsa-with-aes-128-cbc-sha") | str("rsa-with-aes-256-cbc-sha") | str("dhe-rsa-with-aes-256-cbc-sha") | str("ecdhe-rsa-with-rc4-128-sha") | str("ecdhe-rsa-with-3des-ede-cbc-sha") | str("ecdhe-rsa-with-aes-128-cbc-sha") | str("ecdhe-rsa-with-aes-256-cbc-sha") | str("rsa-with-aes-128-cbc-sha256") | str("rsa-with-aes-256-cbc-sha256") | str("dhe-rsa-with-aes-128-cbc-sha256") | str("dhe-rsa-with-aes-256-cbc-sha256") | str("rsa-with-aes-128-gcm-sha256") | str("rsa-with-aes-256-gcm-sha384") | str("dhe-rsa-with-aes-128-gcm-sha256") | str("dhe-rsa-with-aes-256-gcm-sha384") | str("ecdhe-rsa-with-aes-128-cbc-sha256") | str("ecdhe-rsa-with-aes-256-cbc-sha384") | str("ecdhe-rsa-with-aes-128-gcm-sha256") | str("ecdhe-rsa-with-aes-256-gcm-sha384"))
                                    ),
                                    b(str("mutual-authentication"),
                                        c(
                                            a(str("certificate-authority"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("control"),
                                c(
                                    b(str("allowed-sources"),
                                      ipv4addr
                                    ),
                                    a(str("connection-limit"), arg)
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    b(str("flag"),
                                      (str("lighttpd") | str("juise") | str("all"))
                                    )
                                )
                            ),
                            str("enable-explorer")
                        )
                    ),
                    b(str("subscriber-management-helper"),
                      smihelperd_type
                    ),
                    b(str("dhcp-local-server"),
                      jdhcp_local_server_type
                    ),
                    b(str("dhcp-proxy-client"),
                      jdhcp_proxy_client_type
                    ),
                    b(str("database-replication"),
                      bdbrepd_type
                    ),
                    b(str("web-management"),
                        c(
                            b(str("traceoptions"),
                              httpd_traceoptions_type
                            ),
                            a(str("management-url"), arg),
                            b(str("http"),
                                c(
                                    a(str("port"), arg),
                                    b(str("interface"),
                                      interface_name
                                    )
                                )
                            ),
                            b(str("https"),
                                c(
                                    a(str("port"), arg),
                                    c(
                                      a(str("local-certificate"), arg),
                                      a(str("pki-local-certificate"), arg),
                                      str("system-generated-certificate")
                                    ),
                                    b(str("interface"),
                                      interface_name
                                    )
                                )
                            ),
                            b(str("control"),
                                c(
                                    a(str("max-threads"), arg)
                                )
                            ),
                            b(str("session"),
                                c(
                                    a(str("idle-timeout"), arg),
                                    a(str("session-limit"), arg)
                                )
                            )
                        )
                    ),
                    b(str("static-subscribers"),
                      jsscd_static_subscribers_type
                    ),
                    b(str("subscriber-management"),
                      smid_type
                    ),
                    b(str("resource-monitor"),
                      resource_monitor_type
                    ),
                    b(str("bbe-stats-service"),
                      bbe_stats_type
                    ),
                    b(str("extensible-subscriber-services"),
                        c(
                            b(str("maximum-subscribers"),
                                c(
                                      arg
                                )
                            ),
                            b(str("commit-interval"),
                                c(
                                      arg
                                )
                            ),
                            b(str("flat-file-accounting-interval"),
                                c(
                                      arg
                                )
                            ),
                            b(str("flat-file-rollover-interval"),
                                c(
                                      arg
                                )
                            ),
                            b(str("logical-interface-unit-range"),
                                c(
                                    a(str("low"), arg),
                                    a(str("high"), arg)
                                )
                            ),
                            b(str("dictionary"),
                                c(
                                      filename
                                )
                            ),
                            b(str("flat-file-accounting-format"),
                                c(
                                    c(
                                      str("ipdr"),
                                      str("csv")
                                    )
                                )
                            ),
                            b(str("access-profile"),
                                c(
                                      arg
                                )
                            ),
                            a(str("flat-file-profile"), arg)
                        )
                    ),
                    b(str("dhcp"),
                        c(
                            b(str("maximum-lease-time"),
                              (str("infinite") | arg)
                            ),
                            b(str("default-lease-time"),
                              (str("infinite") | arg)
                            ),
                            a(str("domain-name"), arg),
                            a(str("name-server"), arg),
                            a(str("domain-search"), arg),
                            a(str("wins-server"), arg),
                            a(str("router"), arg),
                            a(str("boot-file"), arg),
                            a(str("boot-server"), arg),
                            b(str("next-server"),
                              ipv4addr
                            ),
                            b(str("server-identifier"),
                              ipv4addr
                            ),
                            b(a(str("option"), arg),
                                sc(
                                    c(
                                      b(str("flag"),
                                        (str("true") | str("false") | str("on") | str("off"))
                                      ),
                                      a(str("byte"), arg),
                                      a(str("short"), arg),
                                      a(str("unsigned-short"), arg),
                                      a(str("integer"), arg),
                                      a(str("unsigned-integer"), arg),
                                      a(str("string"), arg),
                                      b(str("ip-address"),
                                        ipv4addr
                                      ),
                                      b(str("array"),
                                          c(
                                              c(
                                                b(str("flag"),
                                                  (str("true") | str("false") | str("on") | str("off"))
                                                ),
                                                a(str("byte"), arg),
                                                a(str("short"), arg),
                                                a(str("unsigned-short"), arg),
                                                a(str("integer"), arg),
                                                a(str("unsigned-integer"), arg),
                                                a(str("string"), arg),
                                                b(str("ip-address"),
                                                  ipv4addr
                                                )
                                              )
                                          )
                                      ),
                                      a(str("byte-stream"), arg)
                                    )
                                )
                            ).as(:oneline),
                            b(str("sip-server"),
                                c(
                                    a(str("name"), arg),
                                    a(str("address"), arg)
                                )
                            ),
                            b(str("traceoptions"),
                              dhcp_traceoptions_type
                            ),
                            b(a(str("pool"), arg),
                                c(
                                    b(str("address-range"),
                                        sc(
                                            b(str("low"),
                                              ipv4addr
                                            ),
                                            b(str("high"),
                                              ipv4addr
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("exclude-address"), arg),
                                    b(str("maximum-lease-time"),
                                      (str("infinite") | arg)
                                    ),
                                    b(str("default-lease-time"),
                                      (str("infinite") | arg)
                                    ),
                                    a(str("domain-name"), arg),
                                    a(str("name-server"), arg),
                                    a(str("domain-search"), arg),
                                    a(str("wins-server"), arg),
                                    a(str("router"), arg),
                                    a(str("boot-file"), arg),
                                    a(str("boot-server"), arg),
                                    b(str("next-server"),
                                      ipv4addr
                                    ),
                                    b(str("server-identifier"),
                                      ipv4addr
                                    ),
                                    b(a(str("option"), arg),
                                        sc(
                                            c(
                                              b(str("flag"),
                                                (str("true") | str("false") | str("on") | str("off"))
                                              ),
                                              a(str("byte"), arg),
                                              a(str("short"), arg),
                                              a(str("unsigned-short"), arg),
                                              a(str("integer"), arg),
                                              a(str("unsigned-integer"), arg),
                                              a(str("string"), arg),
                                              b(str("ip-address"),
                                                ipv4addr
                                              ),
                                              b(str("array"),
                                                  c(
                                                      c(
                                                        b(str("flag"),
                                                          (str("true") | str("false") | str("on") | str("off"))
                                                        ),
                                                        a(str("byte"), arg),
                                                        a(str("short"), arg),
                                                        a(str("unsigned-short"), arg),
                                                        a(str("integer"), arg),
                                                        a(str("unsigned-integer"), arg),
                                                        a(str("string"), arg),
                                                        b(str("ip-address"),
                                                          ipv4addr
                                                        )
                                                      )
                                                  )
                                              ),
                                              a(str("byte-stream"), arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("sip-server"),
                                        c(
                                            a(str("name"), arg),
                                            a(str("address"), arg)
                                        )
                                    )
                                )
                            ),
                            b(a(str("static-binding"), arg),
                                c(
                                    a(str("fixed-address"), arg),
                                    a(str("host-name"), arg),
                                    b(str("client-identifier"),
                                        sc(
                                            c(
                                              a(str("ascii"), arg),
                                              a(str("hexadecimal"), arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("domain-name"), arg),
                                    a(str("name-server"), arg),
                                    a(str("domain-search"), arg),
                                    a(str("wins-server"), arg),
                                    a(str("router"), arg),
                                    a(str("boot-file"), arg),
                                    a(str("boot-server"), arg),
                                    b(str("next-server"),
                                      ipv4addr
                                    ),
                                    b(str("server-identifier"),
                                      ipv4addr
                                    ),
                                    b(a(str("option"), arg),
                                        sc(
                                            c(
                                              b(str("flag"),
                                                (str("true") | str("false") | str("on") | str("off"))
                                              ),
                                              a(str("byte"), arg),
                                              a(str("short"), arg),
                                              a(str("unsigned-short"), arg),
                                              a(str("integer"), arg),
                                              a(str("unsigned-integer"), arg),
                                              a(str("string"), arg),
                                              b(str("ip-address"),
                                                ipv4addr
                                              ),
                                              b(str("array"),
                                                  c(
                                                      c(
                                                        b(str("flag"),
                                                          (str("true") | str("false") | str("on") | str("off"))
                                                        ),
                                                        a(str("byte"), arg),
                                                        a(str("short"), arg),
                                                        a(str("unsigned-short"), arg),
                                                        a(str("integer"), arg),
                                                        a(str("unsigned-integer"), arg),
                                                        a(str("string"), arg),
                                                        b(str("ip-address"),
                                                          ipv4addr
                                                        )
                                                      )
                                                  )
                                              ),
                                              a(str("byte-stream"), arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("sip-server"),
                                        c(
                                            a(str("name"), arg),
                                            a(str("address"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("service-deployment"),
                        c(
                            a(str("local-certificate"), arg),
                            b(str("source-address"),
                              ipv4addr
                            ),
                            b(a(str("servers"), arg),
                                c(
                                    a(str("port"), arg),
                                    a(str("user"), arg),
                                    b(str("security-options"),
                                        c(
                                            c(
                                              str("tls"),
                                              str("ssl3")
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("beep") | str("profile") | str("application") | str("io") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("outbound-ssh"),
                        c(
                            a(str("routing-instance"), arg),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), enum(str("configuration") | str("connectivity") | str("all"))).as(:oneline)
                                )
                            ),
                            b(a(str("client"), arg),
                                c(
                                    str("disable-ssh-security-settings"),
                                    a(str("device-id"), arg),
                                    b(str("secret"),
                                      unreadable
                                    ),
                                    b(str("keep-alive"),
                                        c(
                                            a(str("retry"), arg),
                                            a(str("timeout"), arg)
                                        )
                                    ),
                                    b(str("reconnect-strategy"),
                                      (str("sticky") | str("in-order"))
                                    ),
                                    b(str("services"),
                                      (str("netconf"))
                                    ),
                                        c(
                                            a(str("port"), arg),
                                            a(str("retry"), arg),
                                            a(str("timeout"), arg)
                                        )
                                )
                            )
                        )
                    ),
                    b(str("remote-device-management"),
                        c(
                            b(str("service-device"),
                              service_device_object
                            )
                        )
                    ),
                    b(str("tcp-forwarding"),
                        c(
                            b(str("listening-port"),
                                s(
                                        arg,
                                  a(str("listening-address"), arg),
                                  c(
                                    b(str("forwarding-address"),
                                      ipv4addr
                                    ),
                                    a(str("forwarding-port"), arg),
                                    a(str("max-connections"), arg),
                                    a(str("allowed-source"), arg)
                                  )
                                )
                            )
                        )
                    ),
                    str("transport")
                )
            ),
            str("auto-snapshot"),
            str("unattended-boot"),
            str("jdos"),
            str("dgasp-int"),
            str("dgasp-usb"),
            a(str("domain-name"), arg),
            a(str("domain-search"), arg),
            str("no-hidden-commands"),
            b(str("backup-router"),
                sc(
                      ipv4addr,
                    b(str("destination"),
                      ipv4prefix
                    )
                )
            ).as(:oneline),
            b(str("inet6-backup-router"),
                sc(
                    b(str("destination"),
                      ipv6prefix,
                      ipv6addr
                    )
                )
            ).as(:oneline),
            a(str("time-zone"), arg),
            str("use-imported-time-zones"),
            str("regex-additive-logic"),
            str("switchover-on-routing-crash"),
            str("default-address-selection"),
            str("ndcpp-compliant"),
            a(str("nd-maxmcast-solicit"), arg),
            a(str("nd-maxucast-retry"), arg),
            a(str("nd-retransmit-timer"), arg),
            a(str("nd-system-cache-limit"), arg),
            a(str("arp-system-cache-limit"), arg),
            str("arp-enhanced-scale"),
            str("no-neighbor-learn"),
            str("no-multicast-echo"),
            str("no-redirects"),
            str("no-redirects-ipv6"),
            str("nd-override-preferred-src"),
            str("no-ping-record-route"),
            str("no-ping-time-stamp"),
            b(str("dump-device"),
              (str("boot-device") | str("usb") | str("compact-flash") | str("removable-compact-flash") | arg)
            ),
            b(str("arp"),
                c(
                    a(str("aging-timer"), arg),
                    b(str("interfaces"),
                        c(
                              arp_interface_type
                        )
                    ),
                    str("passive-learning"),
                    str("purging"),
                    str("gratuitous-arp-on-ifup"),
                    a(str("gratuitous-arp-delay"), arg),
                    str("non-subscriber-no-reply"),
                    str("proactive-arp-detection")
                )
            ),
            a(str("personality-file-list-of-directories"), arg),
            a(str("saved-core-files"), arg),
            str("saved-core-context"),
            str("no-saved-core-context"),
            b(str("kernel-replication"),
                c(
                    b(str("system-reboot"),
                      (str("recovery-failure"))
                    ),
                    str("no-syscall-trace"),
                    str("no-multithreading")
                )
            ),
            str("mirror-flash-on-disk"),
            b(str("icmp-rate-limit"),
                sc(
                    a(str("packet-rate"), arg),
                    a(str("bucket-size"), arg)
                )
            ).as(:oneline),
            str("tcp-ack-rst-syn"),
            str("management-instance"),
            b(str("demux-options"),
                c(
                    str("use-underlying-interface-mac")
                )
            ),
            b(str("internet-options"),
                c(
                    b(str("icmpv4-rate-limit"),
                        sc(
                            a(str("packet-rate"), arg),
                            a(str("bucket-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("icmpv6-rate-limit"),
                        sc(
                            a(str("packet-rate"), arg),
                            a(str("bucket-size"), arg)
                        )
                    ).as(:oneline),
                    str("path-mtu-discovery"),
                    str("no-path-mtu-discovery"),
                    str("gre-path-mtu-discovery"),
                    str("no-gre-path-mtu-discovery"),
                    str("ipip-path-mtu-discovery"),
                    str("no-ipip-path-mtu-discovery"),
                    b(str("source-port"),
                        c(
                            a(str("upper-limit"), arg)
                        )
                    ),
                    str("source-quench"),
                    str("no-source-quench"),
                    a(str("tcp-mss"), arg),
                    str("tcp-drop-synfin-set"),
                    str("no-tcp-rfc1323"),
                    str("no-tcp-rfc1323-paws"),
                    str("ipv6-reject-zero-hop-limit"),
                    str("no-ipv6-reject-zero-hop-limit"),
                    a(str("ipv6-duplicate-addr-detection-transmits"), arg),
                    str("ipv6-path-mtu-discovery"),
                    str("no-ipv6-path-mtu-discovery"),
                    a(str("ipv6-path-mtu-discovery-timeout"), arg),
                    b(str("no-tcp-reset"),
                      (str("drop-tcp-with-syn-only") | str("drop-all-tcp"))
                    )
                )
            ),
            b(str("authentication-order"),
              (str("radius") | str("tacplus") | str("password"))
            ),
            b(str("location"),
              location_type
            ),
            b(str("ports"),
                c(
                    b(str("console"),
                      tty_port_object
                    ),
                    b(str("auxiliary"),
                      tty_port_object
                    )
                )
            ),
            b(str("diag-port-authentication"),
                c(
                    a(str("plain-text-password-value"), arg),
                    a(str("encrypted-password"), arg)
                )
            ),
            b(str("pic-console-authentication"),
                c(
                    a(str("plain-text-password-value"), arg),
                    a(str("encrypted-password"), arg)
                )
            ),
            b(str("boot-loader-authentication"),
                c(
                    a(str("plain-text-password-value"), arg),
                    a(str("encrypted-password"), arg)
                )
            ),
            b(str("name-server"),
              nameserver_object
            ),
            b(str("radius-server"),
              radius_server_object
            ),
            b(str("dynamic-profile-options"),
              dynamic_profile_option_object
            ),
            b(str("tacplus-server"),
              tacplus_server_object
            ),
            b(str("password-options"),
                c(
                    str("tacplus-authorization")
                )
            ),
            b(str("radius-options"),
                c(
                    b(str("password-protocol"),
                      (str("mschap-v2"))
                    ),
                    str("enhanced-accounting"),
                    b(str("attributes"),
                        c(
                            b(str("nas-ip-address"),
                              ipaddr
                            ),
                            a(str("nas-id"), arg)
                        )
                    )
                )
            ),
            b(str("tacplus-options"),
                c(
                    a(str("service-name"), arg),
                    a(str("authorization-time-interval"), arg),
                    str("strict-authorization"),
                    str("no-strict-authorization"),
                    c(
                      str("no-cmd-attribute-value"),
                      str("exclude-cmd-attribute")
                    ),
                    str("enhanced-accounting"),
                    str("timestamp-and-timezone")
                )
            ),
            b(str("accounting"),
                c(
                    b(str("events"),
                      (str("login") | str("change-log") | str("interactive-commands"))
                    ),
                    a(str("enhanced-avs-max"), arg),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("all") | str("events") | str("config") | str("radius") | str("tacplus"))).as(:oneline)
                        )
                    ),
                    b(str("destination"),
                        c(
                            b(str("radius"),
                                c(
                                    b(str("server"),
                                      radius_server_object
                                    )
                                )
                            ),
                            b(str("tacplus"),
                                c(
                                    b(str("server"),
                                      tacplus_server_object
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            str("allow-v4mapped-packets"),
            str("allow-6pe-traceroute"),
            str("allow-l3vpn-traceroute-src-select"),
            str("allow-6vpe-traceroute-src-select"),
            str("donot-disable-ip6op-ondad"),
            b(str("schema"),
                c(
                    b(str("openconfig"),
                        c(
                            str("unhide")
                        )
                    )
                )
            ),
            b(a(str("static-host-mapping"), arg),
                c(
                    b(str("inet"),
                      ipv4addr
                    ),
                    b(str("inet6"),
                      ipv6addr
                    ),
                    b(str("sysid"),
                      sysid
                    ),
                    a(str("alias"), arg)
                )
            ),
            b(str("syslog"),
                c(
                    b(str("archive"),
                      archive_object
                    ),
                    b(a(str("user"), arg),
                        c(
                              syslog_object.as(:oneline),
                            b(str("match"),
                              regular_expression
                            ),
                            str("allow-duplicates"),
                            a(str("match-strings"), arg)
                        )
                    ),
                    a(str("host"), str("other-routing-engine") | str("scc-master") | str("sfc0-master") | arg,
                        c(
                              syslog_object.as(:oneline),
                            b(str("match"),
                              regular_expression
                            ),
                            str("allow-duplicates"),
                            a(str("port"), arg),
                            b(str("facility-override"),
                              (str("authorization") | str("daemon") | str("ftp") | str("kernel") | str("user") | str("local0") | str("local1") | str("local2") | str("local3") | str("local4") | str("local5") | str("local6") | str("local7"))
                            ),
                            a(str("log-prefix"), arg),
                            b(str("source-address"),
                              ipaddr
                            ),
                            a(str("routing-instance"), arg),
                            str("explicit-priority"),
                            str("exclude-hostname"),
                            a(str("match-strings"), arg),
                            b(str("structured-data"),
                                c(
                                    c(
                                      str("brief")
                                    )
                                )
                            )
                        )
                    ),
                    str("allow-duplicates"),
                    b(a(str("file"), arg),
                        c(
                              syslog_object.as(:oneline),
                            b(str("match"),
                              regular_expression
                            ),
                            str("allow-duplicates"),
                            b(str("archive"),
                              archive_object
                            ),
                            str("explicit-priority"),
                            a(str("match-strings"), arg),
                            b(str("structured-data"),
                                c(
                                    c(
                                      str("brief")
                                    )
                                )
                            )
                        )
                    ),
                    a(str("console"), enum(str("any") | str("authorization") | str("daemon") | str("ftp") | str("ntp") | str("security") | str("kernel") | str("user") | str("dfc") | str("external") | str("firewall") | str("pfe") | str("conflict-log") | str("change-log") | str("interactive-commands")),
                        sc(
                            c(
                              str("any"),
                              str("emergency"),
                              str("alert"),
                              str("critical"),
                              str("error"),
                              str("warning"),
                              str("notice"),
                              str("info"),
                              str("none")
                            )
                        )
                    ).as(:oneline),
                    b(str("time-format"),
                        sc(
                            str("year"),
                            str("millisecond")
                        )
                    ).as(:oneline),
                    b(str("source-address"),
                      ipaddr
                    ),
                    a(str("routing-instance"), arg),
                    a(str("log-rotate-frequency"), arg),
                    b(str("server"),
                        c(
                            a(str("routing-instances"), str("all") | str("default") | arg,
                                c(
                                    str("disable")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("tracing"),
                sc(
                    b(str("destination-override"),
                        sc(
                            b(str("syslog"),
                                sc(
                                    b(str("host"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline)
                        )
                    ).as(:oneline)
                )
            ).as(:oneline),
            str("encrypt-configuration-files"),
            str("compress-configuration-files"),
            str("no-compress-configuration-files"),
            a(str("max-configurations-on-flash"), arg),
            a(str("max-configuration-rollbacks"), arg),
            b(str("archival"),
                c(
                    b(str("configuration"),
                        c(
                            c(
                              a(str("transfer-interval"), arg),
                              str("transfer-on-commit")
                            ),
                            a(str("routing-instance"), arg),
                            b(a(str("archive-sites"), arg),
                                sc(
                                    b(str("password"),
                                      unreadable
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("extensions"),
                c(
                    b(a(str("providers"), arg),
                        c(
                            b(a(str("license-type"), arg),
                                sc(
                                    a(str("deployment-scope"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("extension-service"),
                        c(
                            b(str("application"),
                                c(
                                    str("refresh"),
                                    a(str("refresh-from"), arg),
                                    b(str("file"),
                                      jet_scripts_file_type
                                    ),
                                    b(str("traceoptions"),
                                      script_traceoptions
                                    ),
                                    a(str("max-datasize"), arg)
                                )
                            )
                        )
                    ),
                    b(str("resource-limits"),
                        c(
                            b(a(str("process"), arg),
                                c(
                                    b(str("resources"),
                                      resources_type
                                    )
                                )
                            ),
                            b(a(str("package"), arg),
                                c(
                                    b(str("resources"),
                                      resources_type
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("license"),
              license_object
            ),
            b(str("proxy"),
              proxy_object
            ),
            b(str("kernel-options"),
                c(
                    str("select-active-unilist-member")
                )
            ),
            b(str("fips"),
                c(
                    b(str("chassis"),
                        c(
                            a(str("level"), arg)
                        )
                    ),
                    a(str("level"), arg),
                    b(str("self-test"),
                        c(
                            b(str("after-key-generation"),
                              (str("enable") | str("disable"))
                            ),
                            b(str("periodic"),
                                c(
                                    a(str("start-time"), arg),
                                    a(str("day-of-month"), arg),
                                    a(str("month"), arg),
                                    a(str("day-of-week"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("rng"),
                c(
                    c(
                      str("fortuna"),
                      str("hmac-drbg"),
                      str("dyce")
                    )
                )
            ),
            b(str("export-format"),
                c(
                    b(str("json"),
                        c(
                            c(
                              str("verbose"),
                              str("ietf")
                            )
                        )
                    ),
                    b(str("state-data"),
                        c(
                            b(str("json"),
                                c(
                                    c(
                                      str("compact")
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("health-monitor"),
                c(
                    b(str("ifstate-clients"),
                        c(
                            b(str("peer-stuck"),
                                c(
                                    b(str("threshold-level"),
                                      (str("low") | str("medium") | str("high"))
                                    ),
                                    b(str("action"),
                                      (str("alarm") | str("alarm-with-cores") | str("restart"))
                                    )
                                )
                            ),
                            b(str("non-peer-stuck"),
                                c(
                                    b(str("threshold-level"),
                                      (str("low") | str("medium") | str("high"))
                                    ),
                                    b(str("action"),
                                      (str("alarm") | str("alarm-with-cores") | str("restart"))
                                    )
                                )
                            ),
                            b(str("all-clients-stuck"),
                                c(
                                    b(str("threshold-level"),
                                      (str("low") | str("medium") | str("high"))
                                    ),
                                    b(str("action"),
                                      (str("alarm") | str("alarm-with-cores") | str("restart"))
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("packet-forwarding-options"),
                c(
                    str("multicast-statistics"),
                    b(str("eracl-ip6-match"),
                        c(
                            c(
                              str("srcip6-only"),
                              str("srcip6-and-destip6")
                            )
                        )
                    ),
                    b(str("firewall"),
                        c(
                            b(str("iracl-profile"),
                                c(
                                    c(
                                      str("ipv4-src-only")
                                    )
                                )
                            )
                        )
                    ),
                    b(str("packet-format-match"),
                        c(
                            c(
                              str("mpls-packet-format-2"),
                              str("mpls-packet-format-3"),
                              str("mpls-packet-format-4"),
                              str("mpls-packet-format-5"),
                              str("mpls-packet-format-6"),
                              str("mpls-packet-format-7"),
                              str("mpls-packet-format-8")
                            )
                        )
                    ),
                    b(str("dfw-profile"),
                        c(
                            b(str("l2-control-db"),
                                c(
                                    c(
                                      str("evpn-mh-profile"),
                                      str("default-profile")
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("auto-configuration"),
                c(
                    b(str("traceoptions"),
                      autoconf_traceoptions_type
                    )
                )
            ),
            b(str("processes"),
                c(
                    b(str("routing"),
                        c(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            ),
                            c(
                              str("force-32-bit"),
                              str("force-64-bit"),
                              str("auto-64-bit")
                            ),
                            b(str("bgp"),
                                c(
                                    b(str("rib-sharding"),
                                        c(
                                            a(str("number-of-shards"), arg)
                                        )
                                    ),
                                    b(str("update-threading"),
                                        c(
                                            a(str("number-of-threads"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("software-forwarding"),
                        sc(
                              (str("disable"))
                        )
                    ).as(:oneline),
                    b(str("packet-forwarding-engine"),
                        sc(
                              (str("disable"))
                        )
                    ).as(:oneline),
                    b(str("chassis-control"),
                        sc(
                              (str("disable")),
                            b(str("failover"),
                              (str("alternate-media"))
                            )
                        )
                    ).as(:oneline),
                    b(str("service-pics"),
                        sc(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            )
                        )
                    ).as(:oneline),
                    b(str("ntp"),
                        sc(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            )
                        )
                    ).as(:oneline),
                    b(str("watchdog"),
                        sc(
                              (str("enable") | str("disable")),
                            a(str("timeout"), arg)
                        )
                    ).as(:oneline),
                    b(str("process-monitor"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              pmond_traceoptions_type
                            )
                        )
                    ),
                    b(str("resource-cleanup"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              res_cleanupd_traceoptions_type
                            )
                        )
                    ),
                    b(str("routing-socket-proxy"),
                        sc(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            )
                        )
                    ).as(:oneline),
                    b(str("web-management"),
                        sc(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            )
                        )
                    ).as(:oneline),
                    b(str("named-service"),
                        c(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            )
                        )
                    ),
                    b(str("cfm"),
                        sc(
                              (str("disable"))
                        )
                    ).as(:oneline),
                    b(str("general-authentication-service"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("filter"),
                                        c(
                                            b(str("user"),
                                                c(
                                                      arg
                                                )
                                            )
                                        )
                                    ),
                                    a(str("flag"), enum(str("configuration") | str("framework") | str("radius") | str("local-authentication") | str("ldap") | str("address-assignment") | str("jsrc") | str("gx-plus") | str("session-db") | str("profile-db") | str("lib-stats") | str("user-access") | str("nasreq") | str("ocs-backup") | str("s6a") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("smg-service"),
                        c(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            ),
                            b(str("traceoptions"),
                              bbe_smgd_traceoptions_type
                            )
                        )
                    ),
                    b(str("bbe-mib-daemon"),
                        c(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                    ),
                                    a(str("flag"), enum(str("framework") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("bbe-stats-daemon"),
                        c(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                    ),
                                    a(str("flag"), enum(str("framework") | str("general") | str("push-collector") | str("get-collector") | str("manager") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b((str("dhcp-service") | str("dhcp")),
                        c(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            ),
                            b(str("persistent-storage"),
                                ca(
                                    a(str("backup-interval"), arg)
                                )
                            ),
                            b(str("traceoptions"),
                              jdhcp_traceoptions_level_type
                            ),
                            b(str("interface-traceoptions"),
                              jdhcp_interface_traceoptions_level_type
                            ),
                            b(str("log"),
                                c(
                                    b(str("session"),
                                        c(
                                            str("client"),
                                            str("server"),
                                            str("relay"),
                                            str("all"),
                                            b(str("dhcpv6"),
                                                c(
                                                    str("client"),
                                                    str("server"),
                                                    str("relay"),
                                                    str("dynamic-server"),
                                                    str("all")
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("dhcp-snooping-file"),
                                c(
                                      filename,
                                    a(str("write-interval"), arg)
                                )
                            ),
                            b(str("dhcpv6-snooping-file"),
                                c(
                                      filename,
                                    a(str("write-interval"), arg)
                                )
                            ),
                            b(str("ltv-syslog-interval"),
                                c(
                                      arg
                                )
                            ),
                            a(str("accept-max-tcp-connections"), arg),
                            a(str("request-max-tcp-connections"), arg)
                        )
                    ),
                    b(str("diameter-service"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                    ),
                                    a(str("flag"), enum(str("framework") | str("configuration") | str("memory-management") | str("daemon") | str("application") | str("node") | str("diameter-instance") | str("dne") | str("peer") | str("messages") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("mac-validation"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              jsavald_traceoptions_type
                            )
                        )
                    ),
                    b(str("sbc-configuration-process"),
                        c(
                              (str("disable")),
                            b(str("failover"),
                              (str("other-routing-engine") | str("alternate-media"))
                            ),
                            b(str("traceoptions"),
                              sbc_traceoptions
                            )
                        )
                    ),
                    b(str("sdk-service"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              ssd_traceoptions_type
                            )
                        )
                    ),
                    b(str("aaad"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                    ),
                                    a(str("flag"), enum(str("send") | str("send-detail") | str("receive") | str("receive-detail") | str("timeout") | str("state") | str("all"))).as(:oneline),
                                    a(str("peer"), arg)
                                )
                            )
                        )
                    ),
                    b(str("app-engine-virtual-machine-management-service"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              sdk_vmmd_traceoptions_type
                            )
                        )
                    ),
                    b(str("app-engine-management-service"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              sdk_mgmtd_traceoptions_type
                            )
                        )
                    ),
                    b(str("datapath-trace-service"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              datapath_traced_traceoptions_type
                            )
                        )
                    ),
                    b(str("send"),
                        sc(
                              (str("disable"))
                        )
                    ).as(:oneline),
                    b(str("static-subscribers"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                    ),
                                    a(str("flag"), enum(str("configuration") | str("database") | str("general") | str("message") | str("rtsock") | str("statistics") | str("subscriber") | str("gres") | str("issu") | str("authentication") | str("profile") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("extensible-subscriber-services"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            ),
                                            str("microsecond-stamp")
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                    ),
                                    a(str("flag"), enum(str("authentication") | str("configuration") | str("database") | str("dictionary") | str("dynamic") | str("fsm") | str("general") | str("kernel") | str("op-script") | str("statistics") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("kernel-offload-service"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              kod_trace_type
                            )
                        )
                    ),
                    b(str("kernel-health-monitoring"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                              jkhmd_trace_type
                            )
                        )
                    ),
                      daemon_process,
                    b(str("video-monitoring"),
                        sc(
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("remote-device-management"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            ),
                                            str("microsecond-stamp")
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                    ),
                                    a(str("flag"), enum(str("out-of-band") | str("configuration") | str("dictionary") | str("dynamic-profile") | str("general") | str("high-availability") | str("netconf") | str("service-manager") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("slaac-snoopd-service"),
                        c(
                            b(str("persistent-file"),
                                c(
                                      filename,
                                    a(str("write-interval"), arg)
                                )
                            )
                        )
                    ),
                    b(str("tcp-forwarding"),
                        c(
                              (str("disable")),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sc(
                                              arg,
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            ),
                                            str("microsecond-stamp")
                                        )
                                    ).as(:oneline),
                                    b(str("level"),
                                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                                    ),
                                    a(str("flag"), enum(str("configuration") | str("connection") | str("init") | str("message") | str("all"))).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("ddos-protection"),
                c(
                    b(str("traceoptions"),
                      ddos_traceoptions_type
                    ),
                    b(str("global"),
                        c(
                            str("disable-routing-engine"),
                            str("disable-fpc"),
                            str("disable-logging"),
                            str("flow-detection"),
                            a(str("violation-report-rate"), arg),
                            a(str("flow-report-rate"), arg),
                            b(str("flow-detection-mode"),
                              (str("automatic") | str("on") | str("off"))
                            ),
                            b(str("flow-level-control"),
                              (str("drop") | str("keep") | str("police"))
                            )
                        )
                    ),
                    b(str("protocols"),
                        c(
                            b(str("ipv4-unclassified"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ipv6-unclassified"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("resolve"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("other"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("ucast-v4"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mcast-v4"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("ucast-v6"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mcast-v6"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("filter-action"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("other"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("filter-v4"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("filter-v6"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("dynamic-vlan"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ppp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("lcp"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("authentication"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("ipcp"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("ipv6cp"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mplscp"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("isis"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("echo-req"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("echo-rep"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mlppp-lcp"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pppoe"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("padi"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("pado"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("padr"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("pads"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("padt"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("padm"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("padn"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("dhcpv4"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("discover"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("offer"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("request"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("decline"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("ack"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("nak"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("release"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("inform"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("renew"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("force-renew"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("lease-query"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("lease-unassigned"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("lease-unknown"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("lease-active"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("bootp"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("no-message-type"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("bad-packets"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("dhcpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("solicit"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("advertise"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("request"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("confirm"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("renew"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("rebind"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("reply"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("release"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("decline"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("reconfigure"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("information-request"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("relay-forward"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("relay-reply"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("leasequery"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("leasequery-reply"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("leasequery-done"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("leasequery-data"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("virtual-chassis"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("control-high"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("control-low"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("vc-packets"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("vc-ttl-errors"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("icmp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("igmp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ospf"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("rsvp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pim"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("rip"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ptp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("bfd"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("multihop-bfd"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("lmp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ldp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("ldp-hello"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("msdp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("bgp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("vrrp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("telnet"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ftp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ssh"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("snmp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ancp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("igmpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mld"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("egpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("rsvpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("igmpv4v6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ripv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("bfdv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("lmpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ldpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("msdpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("bgpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("vrrpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("telnetv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ftpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("sshv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("snmpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ancpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ospfv3v6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("lacp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("stp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("esmc"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("oam-lfm"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("eoam"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("oam-cfm"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("lldp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("mvrp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pmvrp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("arp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("arp"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pvstp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("isis"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pos"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("mlp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("lookup"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("add"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("delete"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("macpin-exception"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("jfm"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("atm"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pfe-alive"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ttl"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ip-options"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("router-alert"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("non-v4v6"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("redirect"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("multicast-copy"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("exceptions"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mtu-exceeded"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mcast-rpf-err"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("mac-host"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("tunnel-fragment"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("mcast-snoop"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("igmp"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("pim"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mld"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("services"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("packet"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("bsdt"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("demux-autosense"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("reject"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("firewall-host"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("tcp-flags"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("initial"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("established"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("dtcp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("radius"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("server"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("accounting"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("authorization"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ntp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("tacacs"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("dns"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("diameter"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ip-fragments"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("first-fragment"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("trail-fragment"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("l2tp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("gre"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("hbc"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("punt"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("hag"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pimv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("icmpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ndpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("router-solicitation"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("router-advertisement"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("neighbor-solicitation"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("neighbor-advertisement"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("redirect"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("invalid-hop-limit"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("sample"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("syslog"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("host"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("pfe"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("tap"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("sflow"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("re-services"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("captive-portal"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("re-services-v6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("captive-portal"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("fab-probe"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("unclassified"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("other"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("resolve-v4"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("resolve-v6"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("control-v4"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("control-v6"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("host-route-v4"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("host-route-v6"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("filter-v4"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("filter-v6"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            )
                                        )
                                    ),
                                    b(str("control-layer2"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("fw-host"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("mcast-copy"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("rejectv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("l2pt"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("tunnel-ka"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("inline-ka"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("inline-svcs"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("frame-relay"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("frf15"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("frf16"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("amtv4"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("amtv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("syslog"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pim-ctrl"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ospf-hello"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pim-data"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("fip-snooping"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("unknown-l2mc"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("nonucast-switch"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ipmcast-miss"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("urpf-fail"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("l3nhop"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("martian-address"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("l3mc-sgv-hit-icl"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("l3dest-miss"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ipmc-reserved"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("garp-reply"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("l3mtu-fail"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("sample-dest"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("sample-source"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("vcipc-udp"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("vxlan"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("bfd"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("dhcpv4v6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("localnh"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("proto-802-1x"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("all-fiber-channel-enode"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("tcc"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("unclassified"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("ethernet-tcc"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    ),
                                    b(str("iso-tcc"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            str("bypass-aggregate"),
                                            b(str("priority"),
                                              (str("high") | str("medium") | str("low"))
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("pkt-inject"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("ptpv6"),
                                c(
                                    b(str("aggregate"),
                                        c(
                                            a(str("bandwidth"), arg),
                                            a(str("burst"), arg),
                                            a(str("recover-time"), arg),
                                            str("disable-routing-engine"),
                                            str("disable-fpc"),
                                            str("disable-logging"),
                                            b(str("violation"),
                                                c(
                                                    str("disable-logging")
                                                )
                                            ),
                                            b(str("flow-detection-mode"),
                                              (str("automatic") | str("on") | str("off"))
                                            ),
                                            b(str("flow-level-bandwidth"),
                                                c(
                                                    a(str("subscriber"), arg),
                                                    a(str("logical-interface"), arg),
                                                    a(str("physical-interface"), arg)
                                                )
                                            ),
                                            b(str("flow-level-detection"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("automatic") | str("on") | str("off"))
                                                    )
                                                )
                                            ),
                                            b(str("flow-level-control"),
                                                c(
                                                    b(str("subscriber"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("logical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    ),
                                                    b(str("physical-interface"),
                                                      (str("drop") | str("keep") | str("police"))
                                                    )
                                                )
                                            ),
                                            str("no-flow-logging"),
                                            str("timeout-active-flows"),
                                            a(str("flow-detect-time"), arg),
                                            a(str("flow-recover-time"), arg),
                                            a(str("flow-timeout-time"), arg),
                                            b(a(str("fpc"), arg),
                                                c(
                                                    str("disable-fpc"),
                                                    a(str("bandwidth-scale"), arg),
                                                    a(str("burst-scale"), arg),
                                                    a(str("hostbound-queue"), arg)
                                                )
                                            ),
                                            a(str("hostbound-queue"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("ntp"),
                c(
                    b(str("boot-server"),
                      ipaddr
                    ),
                    b(str("interval-range"),
                        sc(
                              arg
                        )
                    ).as(:oneline),
                    b(a(str("authentication-key"), arg),
                        sc(
                            b(str("type"),
                              (str("md5") | str("des") | str("sha1") | str("sha256"))
                            ),
                            b(str("value"),
                              unreadable
                            )
                        )
                    ).as(:oneline),
                    b(a(str("peer"), arg),
                        sc(
                            a(str("key"), arg),
                            a(str("version"), arg),
                            str("prefer")
                        )
                    ).as(:oneline),
                    b(a(str("server"), arg),
                        sc(
                            a(str("key"), arg),
                            a(str("version"), arg),
                            str("prefer"),
                            a(str("routing-instance"), arg)
                        )
                    ).as(:oneline),
                    b(a(str("broadcast"), arg),
                        sc(
                            a(str("routing-instance-name"), arg),
                            a(str("key"), arg),
                            a(str("version"), arg),
                            a(str("ttl"), arg)
                        )
                    ).as(:oneline),
                    str("broadcast-client"),
                    b(str("multicast-client"),
                        sc(
                              ipaddr
                        )
                    ).as(:oneline),
                    a(str("trusted-key"), arg),
                    b(str("threshold"),
                        sc(
                              arg,
                            b(str("action"),
                              (str("accept") | str("reject"))
                            )
                        )
                    ).as(:oneline),
                    b(a(str("source-address"), arg),
                        sc(
                            a(str("routing-instance"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("access-line"),
                c(
                    a(str("adsl-overhead-bytes"), arg),
                    a(str("adsl-total-adjust"), arg),
                    a(str("adsl2-overhead-bytes"), arg),
                    a(str("adsl2-total-adjust"), arg),
                    a(str("adsl2-plus-overhead-bytes"), arg),
                    a(str("adsl2-plus-total-adjust"), arg),
                    a(str("sdsl-overhead-bytes"), arg),
                    a(str("sdsl-overhead-adjust"), arg),
                    a(str("sdsl-total-adjust"), arg),
                    a(str("vdsl-overhead-bytes"), arg),
                    a(str("vdsl-overhead-adjust"), arg),
                    a(str("vdsl-total-adjust"), arg),
                    a(str("vdsl2-overhead-bytes"), arg),
                    a(str("vdsl2-overhead-adjust"), arg),
                    a(str("vdsl2-total-adjust"), arg),
                    a(str("other-overhead-bytes"), arg),
                    a(str("other-overhead-adjust"), arg),
                    a(str("other-total-adjust"), arg),
                    a(str("gfast-overhead-bytes"), arg),
                    a(str("gfast-overhead-adjust"), arg),
                    a(str("gfast-total-adjust"), arg),
                    a(str("vdsl2-annex-q-overhead-bytes"), arg),
                    a(str("vdsl2-annex-q-overhead-adjust"), arg),
                    a(str("vdsl2-annex-q-total-adjust"), arg),
                    a(str("sdsl-bonded-overhead-bytes"), arg),
                    a(str("sdsl-bonded-overhead-adjust"), arg),
                    a(str("sdsl-bonded-total-adjust"), arg),
                    a(str("vdsl2-bonded-overhead-bytes"), arg),
                    a(str("vdsl2-bonded-overhead-adjust"), arg),
                    a(str("vdsl2-bonded-total-adjust"), arg),
                    a(str("gfast-bonded-overhead-bytes"), arg),
                    a(str("gfast-bonded-overhead-adjust"), arg),
                    a(str("gfast-bonded-total-adjust"), arg),
                    a(str("vdsl2-annex-q-bonded-overhead-bytes"), arg),
                    a(str("vdsl2-annex-q-bonded-overhead-adjust"), arg),
                    a(str("vdsl2-annex-q-bonded-total-adjust"), arg),
                    b(str("dsl"),
                        c(
                            b(str("adsl"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("adsl2"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("adsl2-plus"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("sdsl"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("vdsl"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("vdsl2"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("other"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("gfast"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("vdsl2-annex-q"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("sdsl-bonded"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("vdsl2-bonded"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("gfast-bonded"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("vdsl2-annex-q-bonded"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(a(str("type"), arg),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            )
                        )
                    ),
                    b(str("pon"),
                        c(
                            b(str("other"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("gpon"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("xg-pon1"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("twdm-pon"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("xgs-pon"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(str("wdm-pon"),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            ),
                            b(a(str("type"), arg),
                                c(
                                    a(str("overhead-bytes"), arg),
                                    a(str("overhead-adjust"), arg),
                                    a(str("total-adjust"), arg)
                                )
                            )
                        )
                    ),
                    str("hierarchical-access-network-detection"),
                    b(str("attributes"),
                        c(
                            b(str("preference"),
                              (str("pon") | str("dsl"))
                            )
                        )
                    )
                )
            ),
            b(str("master-password"),
                c(
                    a(str("iteration-count"), arg),
                    b(str("pseudorandom-function"),
                      (str("hmac-sha2-256") | str("hmac-sha1") | str("hmac-sha2-512"))
                    )
                )
            ),
            str("dump-on-panic")
        )
    end

    rule(:archive_object) do
        sc(
            a(str("size"), arg),
            a(str("files"), arg),
            str("world-readable"),
            str("no-world-readable"),
            str("binary-data"),
            str("no-binary-data"),
            a(str("transfer-interval"), arg),
            b(str("start-time"),
              time
            ),
            b(a(str("archive-sites"), arg),
                sc(
                    b(str("password"),
                      unreadable
                    ),
                    a(str("routing-instance"), arg)
                )
            ).as(:oneline)
        ).as(:oneline)
    end

    rule(:authentication_object) do
        c(
            a(str("plain-text-password-value"), arg),
            a(str("encrypted-password"), arg),
            str("no-public-keys"),
            a(str("ssh-rsa"), quote | arg,
                sc(
                    a(str("from"), arg)
                )
            ).as(:oneline),
            a(str("ssh-dsa"), quote | arg,
                sc(
                    a(str("from"), arg)
                )
            ).as(:oneline),
            a(str("ssh-ecdsa"), quote | arg,
                sc(
                    a(str("from"), arg)
                )
            ).as(:oneline),
            a(str("ssh-ed25519"), quote | arg,
                sc(
                    a(str("from"), arg)
                )
            ).as(:oneline)
        )
    end

    rule(:autoconf_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("configuration") | str("interfaces") | str("io") | str("rtsock") | str("ui") | str("auth") | str("all"))).as(:oneline)
        )
    end

    rule(:bbe_smgd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("config") | str("main") | str("interface") | str("rpd") | str("service") | str("net") | str("autoconf") | str("demux") | str("session") | str("io") | str("vbf") | str("dhcp") | str("cpcd") | str("pppoe") | str("ppp") | str("rtsock") | str("ui") | str("l2tp") | str("dprof") | str("auth") | str("stats") | str("ucac") | str("snmp") | str("ancp") | str("jssc") | str("gre") | str("hag") | str("redundancy") | str("all"))).as(:oneline)
        )
    end

    rule(:bbe_stats_type) do

    end

    rule(:bdbrepd_type) do
        c(
            b(str("traceoptions"),
              bdbrepd_traceoptions_type
            )
        )
    end

    rule(:bdbrepd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("database") | str("mirror") | str("replication") | str("ui") | str("general") | str("session-db") | str("server") | str("all"))).as(:oneline)
        )
    end

    rule(:daemon_process) do
      b(arg.as(:arg),
        c(
              (str("disable")),
            b(str("failover"),
              (str("other-routing-engine") | str("alternate-media"))
            ),
            a(str("command"), arg)
        )
      ).as(:oneline)
    end

    rule(:datapath_traced_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("datapath-traced-infrastructure") | str("datapath-traced-server") | str("client-management") | str("all"))).as(:oneline)
        )
    end

    rule(:ddos_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("config") | str("events") | str("gres") | str("init") | str("memory") | str("protocol") | str("rtsock") | str("signal") | str("state") | str("timer") | str("ui") | str("ipc") | str("socket") | str("all"))).as(:oneline)
        )
    end

    rule(:dhcp_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("binding") | str("config") | str("conflict") | str("event") | str("ifdb") | str("io") | str("lease") | str("main") | str("misc") | str("option") | str("packet") | str("pool") | str("protocol") | str("relay") | str("rtsock") | str("scope") | str("signal") | str("trace") | str("ui") | str("all"))).as(:oneline)
        )
    end

    rule(:dynamic_profile_option_object) do
        c(
            str("versioning")
        )
    end

    rule(:httpd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("configuration") | str("mgd") | str("webauth") | str("dynamic-vpn") | str("init") | str("all"))).as(:oneline)
        )
    end

    rule(:jdhcp_interface_traceoptions_level_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("state") | str("packet") | str("flow") | str("packet-option") | str("dhcpv6-state") | str("dhcpv6-packet") | str("dhcpv6-packet-option") | str("all"))).as(:oneline)
        )
    end

    rule(:jdhcp_traceoptions_level_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("state") | str("packet") | str("flow") | str("packet-option") | str("dhcpv6-state") | str("dhcpv6-packet") | str("dhcpv6-packet-option") | str("all") | str("database") | str("persistent") | str("lockout-db") | str("interface") | str("rtsock") | str("flow-notify") | str("io") | str("ha") | str("ui") | str("general") | str("fwd") | str("rpd") | str("auth") | str("profile") | str("session-db") | str("performance") | str("statistics") | str("dhcpv6-io") | str("dhcpv6-rpd") | str("dhcpv6-session-db") | str("dhcpv6-general") | str("liveness-detection") | str("security-persistence") | str("mclag") | str("ra-guard"))).as(:oneline)
        )
    end

    rule(:jet_scripts_file_type) do
      b(arg.as(:arg),
        c(
            b(str("checksum"),
                c(
                    a(str("sha-256"), arg)
                )
            ),
            a(str("arguments"), arg),
            str("daemonize"),
            str("respawn-on-normal-exit"),
            a(str("username"), arg),
            a(str("source"), arg),
            a(str("routing-instance"), arg),
            b(str("traceoptions"),
              script_traceoptions
            ),
            str("refresh"),
            a(str("refresh-from"), arg)
        )
      )
    end

    rule(:jkhmd_trace_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("infra") | str("sysctl") | str("jti") | str("ipc") | str("all"))).as(:oneline)
        )
    end

    rule(:jsavald_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("rtsock") | str("general") | str("firewall") | str("database") | str("all"))).as(:oneline)
        )
    end

    rule(:juniper_tenant) do
      b(arg.as(:arg),
        c(
            b(str("interfaces"),
                c(
                      tenant_interfaces_type
                )
            ),
            b(str("routing-instances"),
                c(
                      juniper_routing_instance
                )
            )
        )
      )
    end

    rule(:juniper_transport_profiles) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("online"),
                c(
                    a(str("tx-timeout"), arg),
                    str("session-failover-not-supported"),
                    a(str("diameter-profile"), arg),
                    a(str("service-context-id"), arg),
                    a(str("charging-function-name"), arg),
                    str("single-mscc"),
                    str("no-mscc-in-ccrt"),
                    str("no-initiate-session-on-activation"),
                    str("quota-request-on-activation"),
                    str("all-rgs-on-termination")
                )
            ),
            b(str("offline"),
                c(
                    b(str("charging-gateways"),
                        c(
                            b(str("cdr-release"),
                              (str("r99") | str("r7") | str("r8") | str("r9"))
                            ),
                            b(str("peer-order"),
                                c(
                                    a(str("peer"), arg)
                                )
                            ),
                            b(str("persistent-storage-order"),
                                c(
                                    str("local-storage")
                                )
                            ),
                            a(str("switch-back-time"), arg),
                            a(str("cdr-aggregation-limit"), arg),
                            a(str("mtu"), arg)
                        )
                    ),
                    a(str("charging-function-name"), arg),
                    a(str("container-limit"), arg),
                    a(str("sgsn-mme-change-limit"), arg)
                )
            ),
            b(str("service-mode"),
              (str("maintenance"))
            )
        )
      )
    end

    rule(:juniper_trigger_profiles) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("tariff-time-list"), arg),
            b(str("offline"),
                c(
                    b(str("volume-limit"),
                        sc(
                            arg,
                            b(str("direction"),
                              (str("uplink") | str("both"))
                            )
                        )
                    ).as(:oneline),
                    a(str("time-limit"), arg),
                    b(str("exclude"),
                        c(
                            str("plmn-change"),
                            str("qos-change"),
                            str("rat-change"),
                            str("sgsn-sgw-change"),
                            str("user-location-change"),
                            str("ms-timezone-change"),
                            str("dcca-events")
                        )
                    )
                )
            ),
            b(str("charging-method"),
              (str("none") | str("online") | str("offline") | str("both"))
            ),
            b(str("online"),
                c(
                    b(str("reporting-level"),
                        c(
                            c(
                              str("rating-group"),
                              str("service-identifier")
                            ),
                            str("override")
                        )
                    ),
                    b(str("measurement-method"),
                      (str("none") | str("volume") | str("time") | str("volume-and-time"))
                    ),
                    b(str("quota-threshold"),
                        ca(
                            str("override")
                        )
                    ),
                    a(str("quota-validity-time"), arg),
                    a(str("quota-holding-time"), arg),
                    b(str("grant-quota"),
                        c(
                            a(str("cc-time"), arg),
                            a(str("cc-octet-uplink"), arg),
                            a(str("cc-octet-downlink"), arg),
                            a(str("cc-octet-both"), arg)
                        )
                    ),
                    b(str("requested-service-unit"),
                        c(
                            str("include-quota-holding-time"),
                            a(str("cc-time"), arg),
                            a(str("cc-octet-uplink"), arg),
                            a(str("cc-octet-downlink"), arg),
                            a(str("cc-octet-both"), arg)
                        )
                    ),
                    b(str("cc-failure-handling"),
                        c(
                            str("block-traffic-pending-reauth-no-quota"),
                            str("override"),
                            b(str("result-code-based-action"),
                                c(
                                    b(str("authorization-rejected"),
                                        c(
                                            c(
                                              b(str("blacklist"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    ),
                                    b(str("credit-control-not-applicable"),
                                        c(
                                            c(
                                              b(str("convert-to-offline"),
                                                  c(
                                                      str("grant-grace-quota")
                                                  )
                                              )
                                            )
                                        )
                                    ),
                                    b(str("end-user-service-denied"),
                                        c(
                                            c(
                                              str("disable-online-charging"),
                                              b(str("convert-to-offline"),
                                                  c(
                                                      str("grant-grace-quota")
                                                  )
                                              )
                                            )
                                        )
                                    ),
                                    b(str("user-unknown"),
                                        c(
                                            c(
                                              str("disable-online-charging"),
                                              b(str("convert-to-offline"),
                                                  c(
                                                      str("grant-grace-quota")
                                                  )
                                              )
                                            )
                                        )
                                    ),
                                    b(str("credit-limit-reached"),
                                        c(
                                            c(
                                              b(str("blacklist"),
                                                  sc(
                                                        arg
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("initial-request"),
                                c(
                                    c(
                                      str("grant-grace-quota"),
                                      str("disable-online-charging"),
                                      b(str("convert-to-offline"),
                                          c(
                                              str("grant-grace-quota")
                                          )
                                      )
                                    )
                                )
                            ),
                            b(str("update-request"),
                                c(
                                    c(
                                      str("grant-grace-quota"),
                                      str("disable-online-charging"),
                                      b(str("convert-to-offline"),
                                          c(
                                              str("grant-grace-quota")
                                          )
                                      )
                                    )
                                )
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:juniper_unified_edge_cos_options) do
        c(
            b(a(str("classifier-profiles"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(a(str("qos-class-identifier"), arg),
                        sc(
                            a(str("forwarding-class"), arg),
                            b(str("loss-priority"),
                              (str("low") | str("high"))
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("gbr-bandwidth-pools"), arg),
                c(
                    a(str("maximum-bandwidth"), arg),
                    str("downgrade-gtp-v1-gbr-bearers")
                )
            ),
            b(a(str("resource-threshold-profiles"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("bearers-load"),
                        c(
                            b(str("low"),
                                c(
                                    a(str("percentage"), arg),
                                    a(str("priority-level"), arg)
                                )
                            ),
                            b(str("high"),
                                c(
                                    a(str("percentage"), arg),
                                    a(str("priority-level"), arg)
                                )
                            )
                        )
                    ),
                    b(str("memory"),
                        c(
                            b(str("low"),
                                c(
                                    a(str("percentage"), arg),
                                    a(str("priority-level"), arg)
                                )
                            ),
                            b(str("high"),
                                c(
                                    a(str("percentage"), arg),
                                    a(str("priority-level"), arg)
                                )
                            )
                        )
                    ),
                    b(str("cpu"),
                        c(
                            b(str("low"),
                                c(
                                    a(str("percentage"), arg),
                                    a(str("priority-level"), arg)
                                )
                            ),
                            b(str("high"),
                                c(
                                    a(str("percentage"), arg),
                                    a(str("priority-level"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("cos-policy-profiles"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("default-bearer-qci"),
                        sc(
                              arg,
                            str("upgrade"),
                            str("reject")
                        )
                    ).as(:oneline),
                    b(str("allocation-retention-priority"),
                        sc(
                              arg,
                            str("reject")
                        )
                    ).as(:oneline),
                    b(str("aggregated-qos-control"),
                        c(
                            b(str("maximum-bit-rate-uplink"),
                                sc(
                                      arg,
                                    str("upgrade"),
                                    str("reject")
                                )
                            ).as(:oneline),
                            b(str("maximum-bit-rate-downlink"),
                                sc(
                                      arg,
                                    str("upgrade"),
                                    str("reject")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("pdp-qos-control"),
                        c(
                            b(str("maximum-bit-rate-uplink"),
                                sc(
                                      arg,
                                    str("upgrade"),
                                    str("reject")
                                )
                            ).as(:oneline),
                            b(str("maximum-bit-rate-downlink"),
                                sc(
                                      arg,
                                    str("upgrade"),
                                    str("reject")
                                )
                            ).as(:oneline),
                            b(str("guaranteed-bit-rate-uplink"),
                                sc(
                                      arg,
                                    str("upgrade"),
                                    str("reject")
                                )
                            ).as(:oneline),
                            b(str("guaranteed-bit-rate-downlink"),
                                sc(
                                      arg,
                                    str("upgrade"),
                                    str("reject")
                                )
                            ).as(:oneline),
                            b(a(str("qci"), arg),
                                c(
                                    b(str("maximum-bit-rate-uplink"),
                                        sc(
                                              arg,
                                            str("upgrade"),
                                            str("reject")
                                        )
                                    ).as(:oneline),
                                    b(str("maximum-bit-rate-downlink"),
                                        sc(
                                              arg,
                                            str("upgrade"),
                                            str("reject")
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("policer-action"),
                        c(
                            b(str("non-gbr-bearer"),
                                c(
                                    b(str("violate-action"),
                                      (str("set-loss-priority-high") | str("transmit"))
                                    )
                                )
                            ),
                            b(str("gbr-bearer"),
                                c(
                                    b(str("exceed-action"),
                                      (str("drop") | str("transmit"))
                                    ),
                                    b(str("violate-action"),
                                      (str("set-loss-priority-high") | str("transmit"))
                                    )
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_virtual_chassis_traceoptions) do
        c(
            b(str("file"),
              vchassis_trace_file_type
            ),
            a(str("flag"), enum(str("parse") | str("hello") | str("psn") | str("csn") | str("lsp") | str("normal") | str("task") | str("krt") | str("spf") | str("me") | str("packets") | str("lsp-generation") | str("error") | str("route") | str("state") | str("auto-configuration") | str("graceful-restart") | str("dcp-infra") | str("dcp-dev-state") | str("heartbeat") | str("all")),
                sc(
                    str("send"),
                    str("receive"),
                    str("detail"),
                    str("disable")
                )
            ).as(:oneline)
        )
    end

    rule(:juniper_accounting_options) do
        c(
            b(str("selective-aggregate-interface-stats"),
                sc(
                      (str("disable"))
                )
            ).as(:oneline),
            b(str("periodic-refresh"),
                sc(
                      (str("disable"))
                )
            ).as(:oneline),
            b(a(str("file"), arg),
                c(
                    str("nonpersistent"),
                    a(str("size"), arg),
                    a(str("files"), arg),
                    a(str("transfer-interval"), arg),
                    b(str("start-time"),
                      time
                    ),
                    str("compress"),
                    b(str("backup-on-failure"),
                        c(
                            c(
                              str("master-only"),
                              str("master-and-slave")
                            )
                        )
                    ),
                    str("push-backup-to-master"),
                    b(a(str("archive-sites"), arg),
                        sc(
                            b(str("password"),
                              unreadable
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("interface-profile"), arg),
                c(
                    a(str("file"), arg),
                    a(str("interval"), arg),
                    b(str("fields"),
                        c(
                            str("input-bytes"),
                            str("output-bytes"),
                            str("input-packets"),
                            str("output-packets"),
                            str("input-errors"),
                            str("output-errors"),
                            str("input-multicast"),
                            str("output-multicast"),
                            str("input-unicast"),
                            str("output-unicast"),
                            str("unsupported-protocol"),
                            str("rpf-check-bytes"),
                            str("rpf-check-packets"),
                            str("rpf-check6-bytes"),
                            str("rpf-check6-packets")
                        )
                    )
                )
            ),
            b(a(str("filter-profile"), arg),
                c(
                    a(str("file"), arg),
                    a(str("interval"), arg),
                    b(str("counters"),
                      counter_object
                    )
                )
            ),
            b(a(str("class-usage-profile"), arg),
                c(
                    a(str("file"), arg),
                    a(str("interval"), arg),
                    c(
                      b(str("destination-classes"),
                        dest_class_name_object
                      ),
                      b(str("source-classes"),
                        source_class_name_object
                      )
                    )
                )
            ),
            b(a(str("routing-engine-profile"), arg),
                c(
                    a(str("file"), arg),
                    a(str("interval"), arg),
                    b(str("fields"),
                        c(
                            str("host-name"),
                            str("date"),
                            str("time-of-day"),
                            str("uptime"),
                            str("cpu-load-1"),
                            str("cpu-load-5"),
                            str("cpu-load-15"),
                            str("memory-usage"),
                            str("total-cpu-usage")
                        )
                    )
                )
            ),
            b(a(str("mib-profile"), arg),
                c(
                    a(str("file"), arg),
                    a(str("interval"), arg),
                    b(str("operation"),
                      (str("get") | str("get-next") | str("walk"))
                    ),
                    b(str("object-names"),
                      mib_variable_name_object
                    )
                )
            ),
            b(a(str("flat-file-profile"), arg),
                c(
                    a(str("file"), arg),
                    a(str("interval"), arg),
                    a(str("schema-version"), arg),
                    b(str("fields"),
                        c(
                            str("all-fields"),
                            str("service-accounting"),
                            b(str("general-param"),
                                c(
                                    str("all-fields"),
                                    str("timestamp"),
                                    str("accounting-type"),
                                    str("descr"),
                                    str("routing-instances"),
                                    str("nas-port-id"),
                                    str("line-id"),
                                    str("vlan-id"),
                                    str("logical-interface"),
                                    str("physical-interface"),
                                    str("user-name")
                                )
                            ),
                            b(str("overall-packet"),
                                c(
                                    str("all-fields"),
                                    str("input-bytes"),
                                    str("input-packets"),
                                    str("input-v6-bytes"),
                                    str("input-v6-packets"),
                                    str("output-bytes"),
                                    str("output-packets"),
                                    str("output-v6-bytes"),
                                    str("output-v6-packets"),
                                    str("input-errors"),
                                    str("output-errors"),
                                    str("input-discards")
                                )
                            ),
                            b(str("l2-stats"),
                                c(
                                    str("all-fields"),
                                    str("input-mcast-bytes"),
                                    str("input-mcast-packets")
                                )
                            ),
                            b(str("ingress-stats"),
                                c(
                                    str("all-fields"),
                                    str("queue-id"),
                                    str("input-packets"),
                                    str("input-bytes"),
                                    str("output-packets"),
                                    str("output-bytes"),
                                    str("drop-packets")
                                )
                            ),
                            b(str("egress-stats"),
                                c(
                                    str("all-fields"),
                                    str("queue-id"),
                                    str("input-packets"),
                                    str("input-bytes"),
                                    str("output-packets"),
                                    str("output-bytes"),
                                    str("tail-drop-packets"),
                                    str("red-drop-packets"),
                                    str("red-drop-bytes")
                                )
                            )
                        )
                    ),
                    b(str("format"),
                        c(
                            c(
                              str("ipdr"),
                              str("csv")
                            )
                        )
                    )
                )
            ),
            b(str("cleanup-interval"),
                c(
                    a(str("interval"), arg)
                )
            )
        )
    end

    rule(:counter_object) do
      arg.as(:arg).as(:oneline)
    end

    rule(:dest_class_name_object) do
      arg.as(:arg).as(:oneline)
    end

    rule(:junos_hash_key) do
        c(
            b(str("family"),
                c(
                    b(str("fcoe"),
                        c(
                            b(str("ethernet-interfaces"),
                                c(
                                    b(str("oxid"),
                                      (str("enable") | str("disable"))
                                    )
                                )
                            ),
                            b(str("fabric-interfaces"),
                                c(
                                    b(str("oxid"),
                                      (str("enable") | str("disable"))
                                    )
                                )
                            ),
                            b(str("oxid"),
                              (str("enable") | str("disable"))
                            )
                        )
                    ),
                    b(str("inet"),
                        c(
                            b(str("layer-3"),
                                c(
                                    str("destination-address")
                                )
                            ),
                            b(str("layer-4"),
                                c(
                                    str("gtp-tunnel-endpoint-identifier")
                                )
                            ),
                            str("session-id"),
                            b(str("symmetric-hash"),
                                c(
                                    str("complement")
                                )
                            ),
                            str("no-incoming-port")
                        )
                    ),
                    b(str("inet6"),
                        c(
                            b(str("layer-3"),
                                c(
                                    str("destination-address"),
                                    str("incoming-interface-index"),
                                    str("next-header"),
                                    str("source-address"),
                                    str("traffic-class"),
                                    str("ipv6-flow-label")
                                )
                            ),
                            b(str("layer-4"),
                                c(
                                    str("destination-port"),
                                    str("source-port"),
                                    str("gtp-tunnel-endpoint-identifier")
                                )
                            ),
                            str("session-id"),
                            str("no-incoming-port")
                        )
                    ),
                    b(str("mpls"),
                        c(
                            c(
                              str("label-1"),
                              str("all-labels"),
                              str("no-labels"),
                              str("bottom-label-1")
                            ),
                            str("label-2"),
                            str("label-3"),
                            str("bottom-label-2"),
                            str("bottom-label-3"),
                            str("no-label-1-exp"),
                            b(str("payload"),
                                c(
                                    b(str("ether-pseudowire"),
                                        c(
                                            str("zero-control-word")
                                        )
                                    ),
                                    b(str("ip"),
                                        c(
                                            c(
                                              c(
                                                str("layer-3-only"),
                                                str("enable"),
                                                str("disable")
                                              ),
                                              b(str("port-data"),
                                                  c(
                                                      str("source-msb"),
                                                      str("source-lsb"),
                                                      str("destination-msb"),
                                                      str("destination-lsb")
                                                  )
                                              )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("multiservice"),
                        c(
                            str("source-mac"),
                            str("destination-mac"),
                            str("label-1"),
                            str("label-2"),
                            b(str("payload"),
                                c(
                                    b(str("ip"),
                                        c(
                                            b(str("layer-3"),
                                                c(
                                                    c(
                                                      str("source-ip-only"),
                                                      str("destination-ip-only")
                                                    )
                                                )
                                            ),
                                            str("layer-4"),
                                            str("layer-3-only")
                                        )
                                    )
                                )
                            ),
                            b(str("symmetric-hash"),
                                c(
                                    str("complement")
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:keepalives_type) do
        c(
            a(str("interval"), arg),
            a(str("up-count"), arg),
            a(str("down-count"), arg)
        ).as(:oneline)
    end

    rule(:kod_trace_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("main") | str("vpn-localization-config") | str("vpn-localization-replay") | str("all"))).as(:oneline)
        )
    end

    rule(:l2tp_access_line_object) do
        c(
            str("connection-speed-update")
        )
    end

    rule(:l2tp_destination_object) do
        c(
            a(str("lockout-timeout"), arg),
            b(a(str("address"), arg),
                sc(
                    b(str("access-line-information"),
                        c(
                            str("connection-speed-update")
                        )
                    ),
                    b(a(str("routing-instance"), arg),
                        sc(
                            str("drain")
                        )
                    ).as(:oneline),
                    str("drain")
                )
            ).as(:oneline),
            b(a(str("name"), arg),
                sc(
                    str("drain")
                )
            ).as(:oneline)
        )
    end

    rule(:l2tp_interface_traceoptions) do
      b(arg.as(:arg),
        c(
            a(str("flag"), enum(str("ipc") | str("protocol") | str("packet-dump") | str("system") | str("all"))).as(:oneline),
            b(str("debug-level"),
              (str("error") | str("detail") | str("extensive"))
            )
        )
      )
    end

    rule(:l2tp_tunnel_group_object) do
      b(arg.as(:arg),
        c(
            a(str("l2tp-access-profile"), arg),
            a(str("ppp-access-profile"), arg),
            a(str("aaa-access-profile"), arg),
            a(str("receive-window"), arg),
            a(str("maximum-send-window"), arg),
            a(str("retransmit-interval"), arg),
            a(str("hello-interval"), arg),
            str("hide-avps"),
            str("no-tos-reflect"),
            str("tos-reflect"),
            a(str("tunnel-timeout"), arg),
            b(str("local-gateway"),
                c(
                    b(str("address"),
                      ipv4addr
                    ),
                    a(str("gateway-name"), arg)
                )
            ),
            c(
              b(str("service-interface"),
                interface_unit
              ),
              a(str("service-device-pool"), arg)
            ),
            a(str("dynamic-profile"), arg),
            a(str("tunnel-switch-profile"), arg),
            b(str("syslog"),
              log_object
            ),
            a(str("maximum-sessions"), arg),
            a(str("service-profile"), arg)
        )
      )
    end

    rule(:layer2_pm_family_output_type) do
        c(
            c(
              b(str("interface"),
                interface_name
              ),
              a(str("next-hop-group"), arg),
              b(str("routing-instance"),
                layer2_pm_output_routing_instance_type
              ),
              b(str("vlan"),
                pm_rspan_vlan
              ),
              b(str("bridge-domain"),
                pm_rspan_bridge_domain
              )
            ),
            str("no-filter-check")
        )
    end

    rule(:layer2_pm_output_routing_instance_type) do
      b(arg.as(:arg),
        c(
            b(str("vlan"),
              pm_rspan_vlan
            ),
            b(str("bridge-domain"),
              pm_rspan_bridge_domain
            )
        )
      )
    end

    rule(:ldap_server_object) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            b(str("source-address"),
              ipv4addr
            ),
            a(str("routing-instance"), arg),
            a(str("retry"), arg),
            a(str("timeout"), arg),
            b(str("tls-type"),
              (str("start-tls"))
            ),
            a(str("tls-timeout"), arg),
            b(str("tls-min-version"),
              (str("v1.1") | str("v1.2"))
            ),
            str("no-tls-certificate-check"),
            a(str("tls-peer-name"), arg)
        )
      )
    end

    rule(:ldp_sync_obj) do
        c(
              (str("disable")),
            a(str("hold-time"), arg)
        )
    end

    rule(:ldp_filter_obj) do
        c(
            b(str("match-on"),
              (str("fec") | str("address"))
            ),
            b(str("policy"),
              policy_algebra
            )
        ).as(:oneline)
    end

    rule(:li_policy_addr6_simple_object) do
        c(
              ipv6prefix
        )
    end

    rule(:li_policy_addr_simple_object) do
        c(
              ipv4prefix
        )
    end

    rule(:license_object) do
        c(
            b(str("network-server"),
                c(
                    a(str("address"), arg)
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("all") | str("events") | str("config"))).as(:oneline)
                )
            ),
            b(str("keys"),
                c(
                    a(str("key"), quote | arg)
                )
            ),
            c(
              str("standalone-mode"),
              str("network-mode")
            )
        )
    end

    rule(:lmp_control_channel_type) do
      b(arg.as(:arg),
        c(
            b(str("remote-address"),
              ipaddr
            )
        )
      )
    end

    rule(:localauth_subscriber_object) do
      b(arg.as(:arg),
        c(
            a(str("password"), arg),
            b(str("framed-ip-address"),
              ipv4addr
            ),
            a(str("framed-pool"), arg),
            a(str("delegated-pool"), arg),
            a(str("framed-ipv6-pool"), arg),
            c(
              b(str("target-routing-instance"),
                (str("default") | arg)
              ),
              b(str("target-logical-system"),
                  ca(
                      b(str("target-routing-instance"),
                        (str("default") | arg)
                      )
                  )
              )
            )
        )
      )
    end

    rule(:location_type) do
        c(
            a(str("country-code"), arg),
            a(str("postal-code"), arg),
            a(str("npa-nxx"), arg),
            a(str("latitude"), arg),
            a(str("longitude"), arg),
            a(str("altitude"), arg),
            a(str("lata"), arg),
            a(str("vcoord"), arg),
            a(str("hcoord"), arg),
            a(str("building"), arg),
            a(str("floor"), arg),
            a(str("rack"), arg),
            b(a(str("lcc"), arg),
                c(
                    a(str("floor"), arg),
                    a(str("rack"), arg)
                )
            )
        )
    end

    rule(:log_object) do
        c(
            b(a(str("exclude"), arg),
                c(
                    b(str("destination-address"),
                      ipaddr
                    ),
                    a(str("destination-port"), arg),
                    a(str("event-id"), arg),
                    str("failure"),
                    a(str("interface-name"), arg),
                    a(str("policy-name"), arg),
                    a(str("process"), arg),
                    a(str("protocol"), arg),
                    b(str("source-address"),
                      ipaddr
                    ),
                    a(str("source-port"), arg),
                    str("success"),
                    a(str("username"), arg)
                )
            ),
            a(str("limit"), arg),
            b(str("cache"),
                c(
                    b(a(str("exclude"), arg),
                        c(
                            b(str("destination-address"),
                              ipaddr
                            ),
                            a(str("destination-port"), arg),
                            a(str("event-id"), arg),
                            str("failure"),
                            a(str("interface-name"), arg),
                            a(str("policy-name"), arg),
                            a(str("process"), arg),
                            a(str("protocol"), arg),
                            b(str("source-address"),
                              ipaddr
                            ),
                            a(str("source-port"), arg),
                            str("success"),
                            a(str("username"), arg)
                        )
                    ),
                    a(str("limit"), arg)
                )
            ),
            b(a(str("host"), arg),
                c(
                        sc(
                            c(
                              str("any"),
                              str("emergency"),
                              str("alert"),
                              str("critical"),
                              str("error"),
                              str("warning"),
                              str("notice"),
                              str("info"),
                              str("none")
                            )
                        ).as(:oneline),
                    b(str("facility-override"),
                      (str("authorization") | str("daemon") | str("ftp") | str("kernel") | str("user") | str("local0") | str("local1") | str("local2") | str("local3") | str("local4") | str("local5") | str("local6") | str("local7"))
                    ),
                    a(str("log-prefix"), arg),
                    a(str("port"), arg),
                    b(str("class"),
                        c(
                            b(str("session-logs"),
                                c(
                                    str("open"),
                                    str("close")
                                )
                            ),
                            str("packet-logs"),
                            str("stateful-firewall-logs"),
                            str("alg-logs"),
                            b(str("nat-logs"),
                                c(
                                    str("deterministic-nat-configuration-log")
                                )
                            ),
                            str("ids-logs"),
                            b(str("pcp-logs"),
                                sc(
                                    str("map"),
                                    str("debug")
                                )
                            ).as(:oneline),
                            b(str("ha-logs"),
                                c(
                                    str("open-synchronized"),
                                    str("close-synchronized")
                                )
                            ),
                            str("urlf-logs")
                        )
                    ),
                    b(str("source-address"),
                      ipv4addr
                    ),
                    b(str("tcp-log"),
                        c(
                            b(str("source-address"),
                              ipaddr
                            ),
                            a(str("vrf-name"), arg),
                            a(str("ssl-profile"), arg)
                        )
                    )
                )
            ),
            a(str("message-rate-limit"), arg)
        )
    end

    rule(:login_class_object) do
      b(arg.as(:arg),
        c(
            b(str("allowed-days"),
              (str("sunday") | str("monday") | str("tuesday") | str("wednesday") | str("thursday") | str("friday") | str("saturday"))
            ),
            b(str("access-start"),
              date
            ),
            b(str("access-end"),
              date
            ),
            a(str("idle-timeout"), arg),
            a(str("logical-system"), arg),
            a(str("tenant"), arg),
            str("login-alarms"),
            a(str("login-script"), arg),
            str("login-tip"),
            str("no-scp-server"),
            str("no-sftp-server"),
            a(str("permissions"), arg),
            b(str("allow-commands"),
              regular_expression
            ),
            b(str("deny-commands"),
              regular_expression
            ),
            b(str("allow-configuration"),
              regular_expression
            ),
            b(str("deny-configuration"),
              regular_expression
            ),
            a(str("allow-commands-regexps"), arg),
            a(str("deny-commands-regexps"), arg),
            a(str("allow-configuration-regexps"), arg),
            a(str("deny-configuration-regexps"), arg),
            str("configuration-breadcrumbs"),
            b(a(str("confirm-commands"), arg),
                c(
                    arg
                )
            ),
            c(
              str("allow-hidden-commands"),
              b(str("no-hidden-commands"),
                  c(
                      a(str("except"), arg)
                  )
              )
            ),
            b(str("cli"),
                c(
                    a(str("prompt"), arg)
                )
            ),
            b(str("security-role"),
              (str("audit-administrator") | str("crypto-administrator") | str("ids-administrator") | str("security-administrator"))
            ),
            b(str("satellite"),
              (str("all"))
            )
        )
      )
    end

    rule(:login_user_object) do
      b(arg.as(:arg),
        sc(
          a(str("full-name"), quote | arg),

            b(str("cli"),
                c(
                    a(str("prompt"), arg)
                )
            ),
            a(str("uid"), arg),
            a(str("class"), arg),
            b(str("authentication"),
              authentication_object
            )
        )
      )
    end

    rule(:lr_interfaces_type) do
      b(arg.as(:arg),
        c(
            a(str("unit"), enum(arg | arg | arg),
                c(
                    b(str("policer-overhead"),
                        ca(
                            a(str("ingress"), arg),
                            a(str("egress"), arg)
                        )
                    ),
                    a(str("alias"), arg),
                    str("enhanced-convergence"),
                    str("proxy-macip-advertisement"),
                    str("virtual-gateway-accept-data"),
                    b(str("peer-psd"),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(str("peer-interface"),
                        c(
                              interface_unit
                        )
                    ),
                    b(str("interface-shared-with"),
                        c(
                            arg
                        )
                    ),
                      (str("disable")),
                    str("passive-monitor-mode"),
                    str("per-session-scheduler"),
                    b(str("account-layer2-overhead"),
                        ca(
                            a(str("ingress"), arg),
                            a(str("egress"), arg)
                        )
                    ),
                    b(str("forwarding-class-accounting"),
                        c(
                            b(str("direction"),
                              (str("ingress") | str("egress") | str("both"))
                            ),
                            b(str("enhanced"),
                                c(
                                    b(str("traffic-type"),
                                      (str("unicast-statistics") | str("multicast-statistics"))
                                    ),
                                    b(str("family"),
                                      (str("inet6") | str("inet") | str("both"))
                                    ),
                                    b(str("direction"),
                                      (str("ingress") | str("egress") | str("both"))
                                    ),
                                    a(str("overhead-bytes"), arg)
                                )
                            )
                        )
                    ),
                    str("clear-dont-fragment-bit"),
                    str("packet-inject-enable"),
                    str("reassemble-packets"),
                    str("services-options"),
                    b(str("rpm"),
                        c(
                            c(
                              c(
                                str("client"),
                                str("server"),
                                str("client-delegate-probes")
                              ),
                              str("twamp-server"),
                              str("twamp-client")
                            )
                        )
                    ),
                    a(str("description"), quote | arg),
                    a(str("metadata"), arg),
                    b(str("dial-options"),
                        c(
                            c(
                              a(str("l2tp-interface-id"), arg),
                              a(str("ipsec-interface-id"), arg)
                            ),
                            c(
                              str("dedicated"),
                              str("shared")
                            )
                        )
                    ),
                    str("actual-transit-statistics"),
                    b(str("demux-source"),
                          enum((str("inet6") | str("inet")))
                    ),
                    b(str("demux-destination"),
                          enum((str("inet6") | str("inet")))
                    ),
                    b(str("demux"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("address"),
                                      (str("source") | str("destination"))
                                    ),
                                    b(str("auto-configure"),
                                      dynamic_ipv4_type
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("address"),
                                      (str("source") | str("destination"))
                                    ),
                                    b(str("auto-configure"),
                                      dynamic_ipv6_type
                                    )
                                )
                            )
                        )
                    ),
                    b(str("encapsulation"),
                      (str("atm-nlpid") | str("atm-cisco-nlpid") | str("atm-snap") | str("atm-vc-mux") | str("atm-ccc-vc-mux") | str("atm-tcc-vc-mux") | str("atm-tcc-snap") | str("atm-ccc-cell-relay") | str("vlan-vci-ccc") | str("ether-over-atm-llc") | str("ether-vpls-over-atm-llc") | str("ppp-over-ether-over-atm-llc") | str("ppp-over-ether") | str("atm-ppp-vc-mux") | str("atm-ppp-llc") | str("atm-mlppp-llc") | str("frame-relay-ppp") | str("frame-relay-ccc") | str("frame-relay") | str("frame-relay-tcc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("ether-vpls-fr") | str("vlan-ccc") | str("ethernet-ccc") | str("vlan-vpls") | str("vlan-bridge") | str("dix") | str("ethernet-vpls") | str("ethernet-bridge") | str("ethernet") | str("vlan") | str("vlan-tcc") | str("multilink-ppp") | str("multilink-frame-relay-end-to-end") | str("ppp-ccc"))
                    ),
                    str("gre"),
                    a(str("mtu"), arg),
                    c(
                      str("point-to-point"),
                      str("multipoint")
                    ),
                    a(str("bandwidth"), arg),
                    a(str("global-layer2-domainid"), arg),
                    b(str("radio-router"),
                      dynamic_ifbw_parms_type
                    ),
                    str("traps"),
                    str("no-traps"),
                    str("routing-services"),
                    str("no-routing-services"),
                    b(str("routing-service"),
                        c(
                              (str("enable") | str("disable"))
                        )
                    ),
                    b(str("arp-resp"),
                        sc(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    b(str("proxy-arp"),
                        sc(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    c(
                      b(str("vlan-id"),
                        (str("none") | arg)
                      ),
                      a(str("vlan-id-range"), arg),
                      a(str("inner-vlan-id-swap-ranges"), arg),
                      a(str("vlan-id-list"), arg),
                      a(str("vlan-tag"), arg),
                      b(str("vlan-tags"),
                          sc(
                              b(str("outer"),
                                (arg | arg | arg)
                              ),
                              c(
                                b(str("inner"),
                                  (arg | arg)
                                ),
                                a(str("inner-range"), arg),
                                a(str("inner-list"), arg)
                              )
                          )
                      ).as(:oneline)
                    ),
                    a(str("deep-vlan-qualified-learning"), arg),
                    a(str("native-inner-vlan-id"), arg),
                    b(str("inner-vlan-id-range"),
                        sc(
                            a(str("start"), arg),
                            a(str("end"), arg)
                        )
                    ).as(:oneline),
                    b(str("accept-source-mac"),
                        c(
                            b(str("mac-address"),
                              mac_list
                            )
                        )
                    ),
                    b(str("input-vlan-map"),
                      vlan_map
                    ),
                    b(str("output-vlan-map"),
                      vlan_map
                    ),
                    str("swap-by-poppush"),
                    a(str("receive-lsp"), arg),
                    a(str("transmit-lsp"), arg),
                    a(str("dlci"), arg),
                    a(str("multicast-dlci"), arg),
                    c(
                      b(str("vci"),
                        atm_vci
                      ),
                      str("allow-any-vci"),
                      a(str("vpi"), arg),
                      a(str("trunk-id"), arg)
                    ),
                    str("no-vpivci-swapping"),
                    c(
                      b(str("psn-vci"),
                        atm_vci
                      ),
                      a(str("psn-vpi"), arg)
                    ),
                    b(str("atm-l2circuit-mode"),
                        sc(
                            c(
                              str("cell"),
                              str("aal5")
                            )
                        )
                    ).as(:oneline),
                    b(str("vci-range"),
                        sc(
                            a(str("start"), arg),
                            a(str("end"), arg)
                        )
                    ).as(:oneline),
                    a(str("trunk-bandwidth"), arg),
                    b(str("multicast-vci"),
                      atm_vci
                    ),
                    b(str("shaping"),
                      dcd_shaping_config
                    ),
                    b(str("oam-period"),
                        sc(
                            ca(
                              str("disable").as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oam-liveness"),
                        c(
                            a(str("up-count"), arg),
                            a(str("down-count"), arg)
                        )
                    ),
                    b(str("ppp-options"),
                      ppp_options_type
                    ),
                    b(str("pppoe-options"),
                      pppoe_options_type
                    ),
                    b(str("pppoe-underlying-options"),
                      pppoe_underlying_options_type
                    ),
                    b(str("advisory-options"),
                      advisory_options_type
                    ),
                    b(str("auto-configure"),
                      auto_configure_vlan_type
                    ),
                    b(str("demux-options"),
                      demux_options_type
                    ),
                    b(str("targeted-distribution"),
                        c(
                            a(str("primary-list"), arg),
                            a(str("backup-list"), arg),
                            a(str("standby-list"), arg)
                        )
                    ),
                    b(str("targeted-options"),
                        c(
                            b(str("weight"),
                              (arg | arg)
                            ),
                            b(str("primary"),
                              interface_device
                            ),
                            b(str("backup"),
                              interface_device
                            ),
                            a(str("group"), arg)
                        )
                    ),
                    c(
                      b(str("keepalives"),
                        keepalives_type
                      ).as(:oneline),
                      str("no-keepalives")
                    ),
                    str("inverse-arp"),
                    a(str("transmit-weight"), arg),
                    b(str("epd-threshold"),
                      epd_threshold_config
                    ).as(:oneline),
                    a(str("cell-bundle-size"), arg),
                    a(str("cell-bundle-timeout"), arg),
                    str("plp-to-clp"),
                    a(str("atm-scheduler-map"), arg),
                    a(str("mrru"), arg),
                    str("short-sequence"),
                    a(str("fragment-threshold"), arg),
                    a(str("drop-timeout"), arg),
                    str("disable-mlppp-inner-ppp-pfc"),
                    a(str("minimum-links"), arg),
                    a(str("multilink-max-classes"), arg),
                    b(str("compression"),
                        c(
                            b(str("rtp"),
                                c(
                                    a(str("f-max-period"), arg),
                                    b(str("queues"),
                                      (str("q0") | str("q1") | str("q2") | str("q3"))
                                    ),
                                    b(str("port"),
                                        sc(
                                            a(str("minimum"), arg),
                                            a(str("maximum"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("maximum-contexts"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    str("interleave-fragments"),
                    b(str("link-layer-overhead"),
                      unsigned_float
                    ),
                    a(str("accounting-profile"), arg),
                    a(str("peer-unit"), arg),
                    b(str("tunnel"),
                        c(
                            b(str("encapsulation"),
                                c(
                                    b(str("vxlan-gpe"),
                                        c(
                                            b(str("source"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    ),
                                                    b(str("interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("tunnel-endpoint"),
                                              (str("vxlan"))
                                            ),
                                            a(str("destination-udp-port"), arg),
                                            a(str("vni"), arg)
                                        )
                                    ),
                                    b(str("udp"),
                                        c(
                                            b(str("source"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    ),
                                                    b(str("interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("source"),
                              ipaddr
                            ),
                            b(str("destination"),
                              ipaddr
                            ),
                            a(str("key"), arg),
                            b(str("backup-destination"),
                              ipaddr
                            ),
                            c(
                              str("allow-fragmentation"),
                              str("do-not-fragment")
                            ),
                            a(str("ttl"), arg),
                            a(str("traffic-class"), arg),
                            a(str("flow-label"), arg),
                            str("path-mtu-discovery"),
                            str("no-path-mtu-discovery"),
                            b(str("routing-instance"),
                                c(
                                    a(str("destination"), arg)
                                )
                            )
                        )
                    ),
                    b(str("compression-device"),
                      interface_unit
                    ),
                    b(str("atm-policer"),
                        c(
                            a(str("input-atm-policer"), arg)
                        )
                    ),
                    b(str("layer2-policer"),
                        c(
                            c(
                              a(str("input-policer"), arg),
                              a(str("input-hierarchical-policer"), arg),
                              a(str("input-three-color"), arg)
                            ),
                            c(
                              b(str("output-policer"),
                                (arg | arg)
                              ),
                              b(str("output-three-color"),
                                (arg | arg)
                              )
                            )
                        )
                    ),
                    b(str("filter"),
                        c(
                            c(
                              b(str("input"),
                                  sc(
                                      arg,
                                      a(str("shared-name"), arg),
                                      a(str("precedence"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            c(
                              b(str("output"),
                                  sc(
                                      arg,
                                      a(str("shared-name"), arg),
                                      a(str("precedence"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ),
                    b(str("multi-chassis-protection"),
                      multi_chassis_protection_group_ifl
                    ),
                    str("statistics"),
                    b(str("esi"),
                        c(
                            b(str("auto-derive"),
                                c(
                                    c(
                                      str("lacp")
                                    )
                                )
                            ),
                              esi,
                            c(
                              str("single-active"),
                              str("all-active")
                            ),
                            b(str("df-election-type"),
                                c(
                                    c(
                                      b(str("preference"),
                                          c(
                                              a(str("value"), arg)
                                          )
                                      )
                                    ),
                                    c(
                                      str("mod")
                                    )
                                )
                            ),
                            b(str("source-bmac"),
                              mac_unicast
                            )
                        )
                    ),
                    c(
                      str("no-auto-virtual-gateway-esi"),
                      b(str("virtual-gateway-esi"),
                          c(
                                esi,
                              c(
                                str("single-active"),
                                str("all-active")
                              )
                          )
                      )
                    ),
                    b(str("service"),
                        c(
                            b(a(str("pcef"), arg),
                                c(
                                    str("activate-all"),
                                    a(str("activate"), arg)
                                )
                            )
                        )
                    ),
                    str("generate-eui64"),
                    str("no-generate-eui64"),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("dhcp"),
                                      dhcp_client_type
                                    ),
                                    b(str("targeted-broadcast"),
                                        c(
                                            c(
                                              str("forward-and-send-to-re"),
                                              str("forward-only")
                                            )
                                        )
                                    ),
                                    str("destination-class-usage"),
                                    str("transit-options-packets"),
                                    str("transit-ttl-exceeded"),
                                    str("receive-options-packets"),
                                    str("receive-ttl-exceeded"),
                                    b(str("accounting"),
                                        c(
                                            b(str("source-class-usage"),
                                                c(
                                                    str("input"),
                                                    str("output")
                                                )
                                            ),
                                            str("destination-class-usage")
                                        )
                                    ),
                                    b(str("mac-validate"),
                                      (str("strict") | str("loose"))
                                    ),
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                sc(
                                                    str("loose")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    a(str("mtu"), arg),
                                    a(str("arp-max-cache"), arg),
                                    a(str("arp-new-hold-limit"), arg),
                                    a(str("tcp-mss"), arg),
                                    str("no-redirects"),
                                    str("no-neighbor-learn"),
                                    str("unconditional-src-learn"),
                                    str("multicast-only"),
                                    str("primary"),
                                    a(str("ipsec-sa"), arg),
                                    str("allow-filter-on-re"),
                                    a(str("demux-source"), arg | arg),
                                    a(str("demux-destination"), arg | arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("simple-filter"),
                                        c(
                                            a(str("input"), arg)
                                        )
                                    ),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("arp"), arg),
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    ),
                                    b(str("service"),
                                        c(
                                            b(str("input"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    ),
                                                    a(str("post-service-filter"), arg)
                                                )
                                            ),
                                            b(str("output"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("next-hop-tunnel"), arg),
                                        c(
                                            a(str("ipsec-vpn"), arg)
                                        )
                                    ),
                                    b(a(str("address"), arg),
                                        c(
                                            b(str("destination"),
                                              ipv4addr
                                            ),
                                            a(str("destination-profile"), arg),
                                            b(str("broadcast"),
                                              ipv4addr
                                            ),
                                            str("primary"),
                                            str("preferred"),
                                            str("master-only"),
                                            b(a(str("multipoint-destination"), arg),
                                                c(
                                                    c(
                                                      a(str("dlci"), arg),
                                                      b(str("vci"),
                                                        atm_vci
                                                      )
                                                    ),
                                                    b(str("shaping"),
                                                      dcd_shaping_config
                                                    ),
                                                    b(str("oam-period"),
                                                        sc(
                                                            ca(
                                                              str("disable").as(:oneline)
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    b(str("oam-liveness"),
                                                        c(
                                                            a(str("up-count"), arg),
                                                            a(str("down-count"), arg)
                                                        )
                                                    ),
                                                    str("inverse-arp"),
                                                    a(str("transmit-weight"), arg),
                                                    b(str("epd-threshold"),
                                                      epd_threshold_config
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(a(str("arp"), arg),
                                                sc(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicast
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(a(str("host-discovery"), arg),
                                                sc(
                                                    a(str("aging-timer"), arg),
                                                    a(str("discovery-interval"), arg)
                                                )
                                            ).as(:oneline),
                                            b(str("web-authentication"),
                                                c(
                                                    str("https"),
                                                    str("http"),
                                                    str("redirect-to-https")
                                                )
                                            ),
                                            b(str("vrrp-group"),
                                              vrrp_group
                                            ),
                                            b(str("virtual-gateway-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("unnumbered-address"),
                                        sc(
                                              interface_unit,
                                            b(str("preferred-source-address"),
                                              (arg | arg)
                                            ),
                                            b(str("destination"),
                                              ipv4addr
                                            ),
                                            a(str("destination-profile"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("location-pool-address"),
                                        c(
                                              arg
                                        )
                                    ),
                                    str("negotiate-address"),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("iso"),
                                c(
                                    a(str("address"), arg),
                                    a(str("mtu"), arg),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("dhcpv6-client"),
                                        c(
                                            b(str("client-type"),
                                              (str("stateful") | str("autoconfig"))
                                            ),
                                            a(str("client-ia-type"), enum(str("ia-na") | str("ia-pd"))),
                                            str("rapid-commit"),
                                            b(str("prefix-delegating"),
                                                c(
                                                    a(str("preferred-prefix-length"), arg),
                                                    a(str("sub-prefix-length"), arg)
                                                )
                                            ),
                                            b(str("client-identifier"),
                                                sc(
                                                    b(str("duid-type"),
                                                      (str("duid-llt") | str("vendor") | str("duid-ll"))
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("req-option"), enum(str("dns-server") | str("domain") | str("ntp-server") | str("time-zone") | str("sip-server") | str("sip-domain") | str("nis-server") | str("nis-domain") | str("fqdn") | str("vendor-spec") | str("zero-touch-redirect"))),
                                            b(str("options"),
                                                c(
                                                    b(a(str("number"), arg),
                                                        sc(
                                                            c(
                                                              a(str("hex-string"), arg)
                                                            )
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("retransmission-attempt"), arg),
                                            str("no-dns-install"),
                                            b(str("update-router-advertisement"),
                                                c(
                                                    b(a(str("interface"), arg),
                                                        c(
                                                            str("managed-configuration"),
                                                            str("no-managed-configuration"),
                                                            str("other-stateful-configuration"),
                                                            str("no-other-stateful-configuration"),
                                                            a(str("max-advertisement-interval"), arg),
                                                            a(str("min-advertisement-interval"), arg),
                                                            str("enable-recursive-dns-server-option"),
                                                            str("no-enable-recursive-dns-server-option")
                                                        )
                                                    )
                                                )
                                            ),
                                            str("update-server")
                                        )
                                    ),
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                sc(
                                                    str("loose")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("accounting"),
                                        c(
                                            b(str("source-class-usage"),
                                                c(
                                                    str("input"),
                                                    str("output")
                                                )
                                            ),
                                            str("destination-class-usage")
                                        )
                                    ),
                                    a(str("mtu"), arg),
                                    a(str("tcp-mss"), arg),
                                    a(str("nd6-stale-time"), arg),
                                    str("no-neighbor-learn"),
                                    str("slaac-enable"),
                                    b(str("ndp-proxy"),
                                        c(
                                            str("interface-restricted")
                                        )
                                    ),
                                    b(str("dad-proxy"),
                                        c(
                                            str("interface-restricted")
                                        )
                                    ),
                                    a(str("nd6-max-cache"), arg),
                                    a(str("nd6-new-hold-limit"), arg),
                                    str("no-redirects"),
                                    str("allow-filter-on-re"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    ),
                                    b(str("service"),
                                        c(
                                            b(str("input"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    ),
                                                    a(str("post-service-filter"), arg)
                                                )
                                            ),
                                            b(str("output"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("address"), arg),
                                        c(
                                            b(str("destination"),
                                              ipv6addr
                                            ),
                                            str("eui-64"),
                                            str("primary"),
                                            str("preferred"),
                                            str("master-only"),
                                            b(a(str("ndp"), arg),
                                                sc(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicast
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(str("vrrp-inet6-group"),
                                              vrrp_group
                                            ),
                                            b(str("web-authentication"),
                                                c(
                                                    str("https"),
                                                    str("http"),
                                                    str("redirect-to-https")
                                                )
                                            ),
                                            b(str("virtual-gateway-address"),
                                              ipv6addr
                                            ),
                                            str("subnet-router-anycast")
                                        )
                                    ),
                                    a(str("demux-source"), arg | arg | arg),
                                    a(str("demux-destination"), arg | arg),
                                    b(str("unnumbered-address"),
                                        sc(
                                              interface_unit,
                                            b(str("preferred-source-address"),
                                              (arg | arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    str("dad-disable"),
                                    str("no-dad-disable"),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    a(str("mtu"), arg),
                                    a(str("maximum-labels"), arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              a(str("input"), arg),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("output-chain"), arg),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("mlppp"),
                                c(
                                    b(str("bundle"),
                                      (arg | arg)
                                    ),
                                    c(
                                      b(str("service-interface"),
                                        interface_device
                                      ),
                                      a(str("service-device-pool"), arg)
                                    ),
                                    a(str("dynamic-profile"), arg)
                                )
                            ),
                            b(str("mlfr-end-to-end"),
                                c(
                                    b(str("bundle"),
                                      interface_unit
                                    )
                                )
                            ),
                            b(str("mlfr-uni-nni"),
                                c(
                                    b(str("bundle"),
                                      interface_unit
                                    )
                                )
                            ),
                            b(str("ccc"),
                                c(
                                    a(str("mtu"), arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              a(str("input"), arg),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("output-chain"), arg),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    str("translate-fecn-and-becn"),
                                    c(
                                      str("translate-discard-eligible"),
                                      str("translate-plp-control-word-de")
                                    ),
                                    str("keep-address-and-control")
                                )
                            ),
                            b(str("tcc"),
                                c(
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("proxy"),
                                        c(
                                            b(str("inet-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("remote"),
                                        c(
                                            b(str("inet-address"),
                                              ipv4addr
                                            ),
                                            b(str("mac-address"),
                                              mac_addr
                                            )
                                        )
                                    ),
                                    b(str("protocols"),
                                      (str("mpls") | str("inet") | str("iso"))
                                    )
                                )
                            ),
                            b(str("vpls"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("interface-mode"),
                                      (str("access") | str("trunk"))
                                    ),
                                    str("vlan-auto-sense"),
                                    b(str("bridge-domain-type"),
                                      (str("svlan") | str("bvlan"))
                                    ),
                                    str("inter-switch-link"),
                                    c(
                                      a(str("vlan-id"), arg),
                                      a(str("vlan-id-list"), arg),
                                      a(str("inner-vlan-id-list"), arg)
                                    ),
                                    b(str("vlan-rewrite"),
                                        c(
                                            b(a(str("translate"), arg),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    c(
                                      b(str("isid-list"),
                                        (str("all-service-groups") | str("all"))
                                      )
                                    ),
                                    b(str("storm-control"),
                                        c(
                                            arg
                                        )
                                    ),
                                    b(str("recovery-timeout"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    )
                                )
                            ),
                            b(str("ethernet-switching"),
                              ethernet_switching_type
                            ),
                            b(str("fibre-channel"),
                              fibre_channel_type
                            ),
                            b(str("pppoe"),
                              pppoe_underlying_options_type
                            ),
                            b(str("any"),
                                c(
                                    b(str("filter"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("group"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("service-domain"),
                      (str("inside") | str("outside"))
                    ),
                    str("copy-tos-to-outer-ip-header"),
                    str("copy-tos-to-outer-ip-header-transit"),
                    str("force-control-packets-on-transit-path"),
                    b(str("load-balancing-options"),
                        c(
                            b(str("preferred-active"),
                              interface_device
                            ),
                            str("disable-hash"),
                            b(str("hash-keys"),
                                c(
                                    b(str("ingress-key"),
                                          enum((str("source-ip") | str("destination-ip") | str("protocol") | str("iif")))
                                    ),
                                    b(str("egress-key"),
                                          enum((str("source-ip") | str("destination-ip") | str("protocol") | str("oif")))
                                    ),
                                    b(str("ipv6-source-prefix-length"),
                                      (str("56") | str("64") | str("96") | str("128"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("mac"),
                      mac_unicast
                    ),
                    b(str("virtual-gateway-v4-mac"),
                      mac_unicast
                    ),
                    b(str("virtual-gateway-v6-mac"),
                      mac_unicast
                    ),
                    b(str("forwarding-options"),
                        c(
                            b(str("load-balance-stateful"),
                                c(
                                    str("per-flow"),
                                    a(str("rebalance"), arg),
                                    b(str("load-type"),
                                      (str("high") | str("medium") | str("low"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("etree-ac-role"),
                      (str("root") | str("leaf"))
                    )
                )
            )
        )
      )
    end

    rule(:lrf_profile_object) do
      b(arg.as(:arg),
        c(
            str("policy-based-logging"),
            str("http-log-multiple-transactions"),
            b(str("rule"),
              lrf_rule_object
            ),
            b(str("collector"),
              lrf_collector_object
            ),
            b(str("vendor-support"),
              (str("ibm"))
            ),
            b(str("template"),
              lrf_template_object
            ),
            b(str("performance-mode"),
              lrf_perf_object
            )
        )
      )
    end

    rule(:lrf_template_object) do
      b(arg.as(:arg),
        c(
            b(str("format"),
              (str("ipfix"))
            ),
            b(str("template-type"),
              (str("ipv4") | str("ipv4-extended") | str("ipv6") | str("ipv6-extended") | str("transport-layer") | str("flow-id") | str("ipflow") | str("ipflow-ts") | str("ipflow-extended") | str("device-data") | str("l7-app") | str("http") | str("subscriber-data") | str("mobile-subscriber") | str("ifl-subscriber") | str("wireline-subscriber") | str("ipflow-tcp-ts") | str("ipflow-tcp") | str("video") | str("dns") | str("status-code-distribution") | str("pcc"))
            ),
            b(str("trigger-type"),
              (str("session-close") | str("volume") | str("time"))
            ),
            a(str("template-tx-interval"), arg)
        )
      )
    end

    rule(:lrf_collector_object) do
      b(arg.as(:arg),
        c(
            b(str("destination"),
                c(
                    b(str("address"),
                      ipv4addr
                    ),
                    a(str("port"), arg)
                )
            ),
            b(str("source-address"),
              ipv4addr
            )
        )
      )
    end

    rule(:lrf_perf_object) do
        c(
            a(str("packet-count"), arg)
        )
    end

    rule(:lrf_rule_object) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("client-to-server") | str("server-to-client") | str("both"))
            ),
            b(str("from"),
              lrf_match_object
            ),
            b(str("then"),
                c(
                    b(str("report"),
                      lrf_report_object
                    )
                )
            )
        )
      )
    end

    rule(:lrf_match_object) do
        c(
            b(a(str("source-prefix-list"), arg),
                sc(
                    str("except")
                )
            ).as(:oneline),
            b(a(str("destination-prefix-list"), arg),
                sc(
                    str("except")
                )
            ).as(:oneline),
            a(str("source-ports"), arg),
            a(str("destination-ports"), arg),
            str("app-unknown"),
            b(str("application-names"),
                c(
                      arg
                )
            ),
            b(str("application-groups"),
                c(
                      arg
                )
            )
        )
    end

    rule(:lrf_report_object) do
        c(
            a(str("volume-limit"), arg),
            a(str("time-limit"), arg),
            a(str("template"), arg),
            a(str("collector"), arg)
        )
    end

    rule(:lsp_set_match_type) do
        c(
            a(str("lsp-name"), arg),
            a(str("lsp-regex"), arg),
            a(str("p2mp-name"), arg),
            a(str("p2mp-regex"), arg),
            c(
              str("egress"),
              str("ingress"),
              str("transit")
            )
        )
    end

    rule(:lsp_nh_obj) do
      b(arg.as(:arg),
        c(
            a(str("preference"), arg),
            a(str("metric"), arg)
        )
      )
    end

    rule(:mac_addr_list_items) do
      arg.as(:arg)
    end

    rule(:mac_list) do
      b(arg.as(:arg),
        c(
            b(str("policer"),
                c(
                    a(str("input"), arg),
                    a(str("output"), arg)
                )
            )
        )
      )
    end

    rule(:mape_object) do
      b(arg.as(:arg),
        c(
            b(str("softwire-address"),
              ipv6addr
            ),
            b(str("ipv4-prefix"),
              ipv4prefix
            ),
            b(str("mape-prefix"),
              ipv6prefix
            ),
            a(str("ea-bits-len"), arg),
            a(str("psid-offset"), arg),
            a(str("psid-length"), arg),
            a(str("mtu-v6"), arg),
            str("version-03"),
            str("v4-reassembly"),
            str("v6-reassembly"),
            str("disable-auto-route")
        )
      )
    end

    rule(:martian_type) do
        s(
                arg,
          c(
            str("exact"),
            str("longer"),
            str("orlonger"),
            a(str("upto"), arg),
            a(str("through"), arg),
            a(str("prefix-length-range"), arg)
          ),
          c(
            str("allow")
          )
        ).as(:oneline)
    end

    rule(:match_l2_flexible_mask) do
        c(
            b(str("match-start"),
              (str("layer-2") | str("layer-3") | str("layer-4") | str("payload"))
            ),
            a(str("byte-offset"), arg),
            a(str("bit-offset"), arg),
            a(str("bit-length"), arg),
            a(str("mask-in-hex"), arg),
            a(str("prefix"), arg),
            a(str("flexible-mask-name"), arg)
        )
    end

    rule(:match_l2_flexible_range) do
        c(
            b(str("match-start"),
              (str("layer-2") | str("layer-3") | str("layer-4") | str("payload"))
            ),
            a(str("byte-offset"), arg),
            a(str("bit-offset"), arg),
            a(str("bit-length"), arg),
            c(
              a(str("range"), arg),
              a(str("range-except"), arg)
            ),
            a(str("flexible-range-name"), arg)
        )
    end

    rule(:match_l3_flexible_mask) do
        c(
            b(str("match-start"),
              (str("layer-3") | str("layer-4") | str("payload"))
            ),
            a(str("byte-offset"), arg),
            a(str("bit-offset"), arg),
            a(str("bit-length"), arg),
            a(str("mask-in-hex"), arg),
            a(str("prefix"), arg),
            a(str("flexible-mask-name"), arg)
        )
    end

    rule(:match_l3_flexible_range) do
        c(
            b(str("match-start"),
              (str("layer-3") | str("layer-4") | str("payload"))
            ),
            a(str("byte-offset"), arg),
            a(str("bit-offset"), arg),
            a(str("bit-length"), arg),
            c(
              a(str("range"), arg),
              a(str("range-except"), arg)
            ),
            a(str("flexible-range-name"), arg)
        )
    end

    rule(:match_flags_value) do
        ca(
            a(str("mask-in-hex"), arg)
        )
    end

    rule(:match_interface_object) do
      arg.as(:arg).as(:oneline)
    end

    rule(:match_interface_object_oam) do
      arg.as(:arg).as(:oneline)
    end

    rule(:match_interface_set_object) do
      arg.as(:arg).as(:oneline)
    end

    rule(:match_li_simple_dscp_value) do
        c(
            c(
              str("af11"),
              str("af12"),
              str("af13"),
              str("af21"),
              str("af22"),
              str("af23"),
              str("af31"),
              str("af32"),
              str("af33"),
              str("af41"),
              str("af42"),
              str("af43"),
              str("ef"),
              str("cs0"),
              str("cs1"),
              str("cs2"),
              str("cs3"),
              str("cs4"),
              str("cs5"),
              str("cs6"),
              str("cs7"),
              str("be"),
              arg
            )
        )
    end

    rule(:match_li_simple_port_value) do
        c(
            c(
              str("ftp-data"),
              str("ftp"),
              str("ssh"),
              str("telnet"),
              str("smtp"),
              str("tacacs"),
              str("tacacs-ds"),
              str("domain"),
              str("dhcp"),
              str("bootps"),
              str("bootpc"),
              str("tftp"),
              str("finger"),
              str("http"),
              str("kerberos-sec"),
              str("pop3"),
              str("sunrpc"),
              str("ident"),
              str("nntp"),
              str("ntp"),
              str("netbios-ns"),
              str("netbios-dgm"),
              str("netbios-ssn"),
              str("imap"),
              str("snmptrap"),
              str("snmp"),
              str("xdmcp"),
              str("bgp"),
              str("ldap"),
              str("mobileip-agent"),
              str("mobilip-mn"),
              str("msdp"),
              str("https"),
              str("snpp"),
              str("biff"),
              str("exec"),
              str("login"),
              str("who"),
              str("cmd"),
              str("syslog"),
              str("printer"),
              str("talk"),
              str("ntalk"),
              str("rip"),
              str("timed"),
              str("klogin"),
              str("kshell"),
              str("ldp"),
              str("krb-prop"),
              str("krbupdate"),
              str("kpasswd"),
              str("socks"),
              str("afs"),
              str("pptp"),
              str("radius"),
              str("radacct"),
              str("zephyr-srv"),
              str("zephyr-clt"),
              str("zephyr-hm"),
              str("nfsd"),
              str("eklogin"),
              str("ekshell"),
              str("rkinit"),
              str("cvspserver"),
              arg
            )
        )
    end

    rule(:match_li_simple_protocol_value) do
        c(
            c(
              str("icmp"),
              str("igmp"),
              str("ipip"),
              str("tcp"),
              str("egp"),
              str("udp"),
              str("rsvp"),
              str("gre"),
              str("esp"),
              str("ah"),
              str("icmp6"),
              str("ospf"),
              str("pim"),
              str("sctp"),
              str("ipv6"),
              str("dstopts"),
              str("routing"),
              str("fragment"),
              str("no-next-header"),
              str("hop-by-hop"),
              str("vrrp"),
              arg
            )
        )
    end

    rule(:match_simple_dscp_value) do
        c(
            c(
              str("af11"),
              str("af12"),
              str("af13"),
              str("af21"),
              str("af22"),
              str("af23"),
              str("af31"),
              str("af32"),
              str("af33"),
              str("af41"),
              str("af42"),
              str("af43"),
              str("ef"),
              str("cs0"),
              str("cs1"),
              str("cs2"),
              str("cs3"),
              str("cs4"),
              str("cs5"),
              str("cs6"),
              str("cs7"),
              str("be"),
              arg
            )
        )
    end

    rule(:match_simple_payload_protocol_value) do
        c(
            c(
              str("icmp"),
              str("igmp"),
              str("ipip"),
              str("tcp"),
              str("egp"),
              str("udp"),
              str("rsvp"),
              str("gre"),
              str("esp"),
              str("ah"),
              str("icmp6"),
              str("ospf"),
              str("pim"),
              str("sctp"),
              str("ipv6"),
              str("no-next-header"),
              str("vrrp"),
              arg
            )
        )
    end

    rule(:match_simple_port_value) do
        c(
            c(
              str("ftp-data"),
              str("ftp"),
              str("ssh"),
              str("telnet"),
              str("smtp"),
              str("tacacs"),
              str("tacacs-ds"),
              str("domain"),
              str("dhcp"),
              str("bootps"),
              str("bootpc"),
              str("tftp"),
              str("finger"),
              str("http"),
              str("kerberos-sec"),
              str("pop3"),
              str("sunrpc"),
              str("ident"),
              str("nntp"),
              str("ntp"),
              str("netbios-ns"),
              str("netbios-dgm"),
              str("netbios-ssn"),
              str("imap"),
              str("snmptrap"),
              str("snmp"),
              str("xdmcp"),
              str("bgp"),
              str("ldap"),
              str("mobileip-agent"),
              str("mobilip-mn"),
              str("msdp"),
              str("https"),
              str("snpp"),
              str("biff"),
              str("exec"),
              str("login"),
              str("who"),
              str("cmd"),
              str("syslog"),
              str("printer"),
              str("talk"),
              str("ntalk"),
              str("rip"),
              str("timed"),
              str("klogin"),
              str("kshell"),
              str("ldp"),
              str("krb-prop"),
              str("krbupdate"),
              str("kpasswd"),
              str("socks"),
              str("afs"),
              str("pptp"),
              str("radius"),
              str("radacct"),
              str("zephyr-srv"),
              str("zephyr-clt"),
              str("zephyr-hm"),
              str("nfsd"),
              str("eklogin"),
              str("ekshell"),
              str("rkinit"),
              str("cvspserver"),
              arg
            )
        )
    end

    rule(:match_simple_protocol_value) do
        c(
            c(
              str("icmp"),
              str("igmp"),
              str("ipip"),
              str("tcp"),
              str("egp"),
              str("udp"),
              str("rsvp"),
              str("gre"),
              str("esp"),
              str("ah"),
              str("icmp6"),
              str("ospf"),
              str("pim"),
              str("sctp"),
              str("dstopts"),
              str("routing"),
              str("fragment"),
              str("hop-by-hop"),
              str("ipv6"),
              str("no-next-header"),
              str("vrrp"),
              arg
            )
        )
    end

    rule(:metric_expression_type) do
        c(
            b(str("metric"),
                sc(
                    b(str("multiplier"),
                      float
                    ),
                    a(str("offset"), arg)
                )
            ).as(:oneline),
            b(str("metric2"),
                sc(
                    b(str("multiplier"),
                      float
                    ),
                    a(str("offset"), arg)
                )
            ).as(:oneline)
        )
    end

    rule(:mib_variable_name_object) do
      arg.as(:arg).as(:oneline)
    end

    rule(:mobile_diameter_profiles) do
        c(
            b(str("gy-profile"),
              mobile_diameter_profile_type_gy
            ),
            b(str("gx-profile"),
              mobile_diameter_profile_type_gx
            )
        )
    end

    rule(:mobile_diameter_profile_type_gx) do
      b(arg.as(:arg),
        c(
            b(str("targets"),
              mobile_diameter_target
            ),
            a(str("request-timeout"), arg),
            b(str("attributes"),
              mobile_diameter_gx_profile_attr_type
            )
        )
      )
    end

    rule(:mobile_diameter_gx_profile_attr_type) do
        c(
            b(str("include"),
                c(
                    a(str("gx-capability-list"), arg),
                    a(str("rule-suggestion"), arg),
                    str("rai"),
                    str("qos-negotiation"),
                    str("qos-upgrade")
                )
            ),
            b(str("exclude"),
                c(
                    str("packet-filter-information"),
                    str("packet-filter-operation"),
                    str("rat-type"),
                    str("default-eps-bearer-qos"),
                    str("an-gw-address"),
                    str("network-request-support"),
                    str("event-trigger"),
                    str("threegpp-rat-type"),
                    str("offline"),
                    str("qos-negotiation"),
                    str("qos-upgrade")
                )
            )
        )
    end

    rule(:mobile_diameter_profile_type_gy) do
      b(arg.as(:arg),
        c(
            b(str("targets"),
              mobile_diameter_target
            ),
            a(str("request-timeout"), arg),
            b(str("attributes"),
              mobile_diameter_gy_profile_attr_type
            )
        )
      )
    end

    rule(:mobile_diameter_gy_profile_attr_type) do
        c(
            b(str("include"),
                c(
                    str("cumulative-used-service-unit"),
                    str("credit-instance-id"),
                    str("service-start-timestamp"),
                    str("mscc-qos-information"),
                    str("framed-ip-address"),
                    str("framed-ipv6-prefix"),
                    str("gprs-negotiated-qos")
                )
            ),
            b(str("exclude"),
                c(
                    str("ps-information"),
                    str("username"),
                    str("user-equipment-info"),
                    str("all-3gpp-avps"),
                    str("qos-information"),
                    str("pdn-connection-id"),
                    str("dynamic-address-flag"),
                    str("serving-node-type"),
                    str("cc-selection-mode"),
                    str("start-time"),
                    str("stop-time"),
                    str("user-location-information")
                )
            )
        )
    end

    rule(:mobile_diameter_target) do
      b(arg.as(:arg),
        c(
            a(str("destination-realm"), arg),
            a(str("destination-host"), arg),
            a(str("priority"), arg),
            a(str("network-element"), arg)
        )
      )
    end

    rule(:mobile_gateway_config_gtp) do
        c(
            a(str("peer-history"), arg),
            b(str("interface"),
                sc(
                      interface_name,
                    b(str("v4-address"),
                      ipv4addr
                    )
                )
            ).as(:oneline),
            a(str("echo-interval"), arg),
            b(str("path-management"),
              (str("enable") | str("disable"))
            ),
            a(str("echo-n3-requests"), arg),
            a(str("echo-t3-response"), arg),
            b(str("path-failure"),
              (str("enable") | str("disable"))
            ),
            a(str("number-of-msgs-for-response-time"), arg),
            b(str("control"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    a(str("forwarding-class"), arg),
                    a(str("n3-requests"), arg),
                    a(str("t3-response"), arg),
                    a(str("dscp-code-point"), arg),
                    str("no-response-cache"),
                    a(str("response-cache-timeout"), arg),
                    str("no-piggyback-support")
                )
            ),
            b(str("data"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("error-indication-interval"), arg)
                )
            ),
            b(str("gn"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    b(str("control"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("n3-requests"), arg),
                            a(str("t3-response"), arg),
                            a(str("dscp-code-point"), arg)
                        )
                    ),
                    b(str("data"),
                        c(
                            b(str("interface"),
                                sc(
                                    a(str("echo-interval"), arg),
                                    b(str("path-management"),
                                      (str("enable") | str("disable"))
                                    ),
                                    a(str("echo-n3-requests"), arg),
                                    a(str("echo-t3-response"), arg),
                                    b(str("path-failure"),
                                      (str("enable") | str("disable"))
                                    ),
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg)
                        )
                    )
                )
            ),
            b(str("gp"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    b(str("control"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("n3-requests"), arg),
                            a(str("t3-response"), arg),
                            a(str("dscp-code-point"), arg)
                        )
                    ),
                    b(str("data"),
                        c(
                            b(str("interface"),
                                sc(
                                    a(str("echo-interval"), arg),
                                    b(str("path-management"),
                                      (str("enable") | str("disable"))
                                    ),
                                    a(str("echo-n3-requests"), arg),
                                    a(str("echo-t3-response"), arg),
                                    b(str("path-failure"),
                                      (str("enable") | str("disable"))
                                    ),
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg)
                        )
                    )
                )
            ),
            b(str("s5"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    b(str("control"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("n3-requests"), arg),
                            a(str("t3-response"), arg),
                            a(str("dscp-code-point"), arg),
                            str("support-16-bit-sequence")
                        )
                    ),
                    b(str("data"),
                        c(
                            b(str("interface"),
                                sc(
                                    a(str("echo-interval"), arg),
                                    b(str("path-management"),
                                      (str("enable") | str("disable"))
                                    ),
                                    a(str("echo-n3-requests"), arg),
                                    a(str("echo-t3-response"), arg),
                                    b(str("path-failure"),
                                      (str("enable") | str("disable"))
                                    ),
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg)
                        )
                    )
                )
            ),
            b(str("s8"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    b(str("control"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("n3-requests"), arg),
                            a(str("t3-response"), arg),
                            a(str("dscp-code-point"), arg),
                            str("support-16-bit-sequence")
                        )
                    ),
                    b(str("data"),
                        c(
                            b(str("interface"),
                                sc(
                                    a(str("echo-interval"), arg),
                                    b(str("path-management"),
                                      (str("enable") | str("disable"))
                                    ),
                                    a(str("echo-n3-requests"), arg),
                                    a(str("echo-t3-response"), arg),
                                    b(str("path-failure"),
                                      (str("enable") | str("disable"))
                                    ),
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg)
                        )
                    )
                )
            ),
            b(a(str("peer-group"), arg),
                c(
                    a(str("routing-instance"), arg),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    b(str("control"),
                        c(
                            str("support-16-bit-sequence"),
                            str("no-piggyback-support")
                        )
                    ),
                    str("gn"),
                    str("gp"),
                    a(str("peer"), arg).as(:oneline)
                )
            ),
            b(str("traceoptions"),
              gtp_traceoptions
            )
        )
    end

    rule(:gtp_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("error") | str("warning") | str("debug") | str("encode") | str("decode") | str("config") | str("events") | str("packet-io") | str("tracker") | str("peer") | str("pathfailure") | str("all"))).as(:oneline)
        )
    end

    rule(:mobile_gateways_ipv6_router_advertisement) do
        c(
            str("disable"),
            a(str("maximum-advertisement-interval"), arg),
            a(str("minimum-advertisement-interval"), arg),
            a(str("maximum-initial-advertisement-interval"), arg),
            a(str("maximum-initial-advertisements"), arg),
            a(str("reachable-time"), arg),
            a(str("retransmission-timer"), arg),
            a(str("router-lifetime"), arg),
            a(str("current-hop-limit"), arg)
        )
    end

    rule(:mobile_smd_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            b(str("level"),
              (str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("init") | str("config") | str("ctxt") | str("svcpic") | str("fsm") | str("ha") | str("waitq") | str("pfem") | str("stats") | str("bulkjob") | str("cos-cac") | str("all"))).as(:oneline)
        )
    end

    rule(:monitor_threshold) do
        ca(
              arg
        ).as(:oneline)
    end

    rule(:monitoring_input_type) do
        c(
            a(str("interface"), arg)
        )
    end

    rule(:monitoring_output_type) do
        c(
            b(str("export-format"),
              (str("cflowd-version-5"))
            ),
            b(str("destination-address"),
              ipv4addr
            ),
            a(str("destination-port"), arg),
            b(str("source-address"),
              ipv4addr
            ),
            a(str("flow-active-timeout"), arg),
            a(str("flow-inactive-timeout"), arg),
            b(str("flow-export-destination"),
              (str("collector-pic") | str("cflowd-collector"))
            ),
            b(str("cflowd"),
              cflowd_monitoring_type
            ),
            b(str("interface"),
              monitor_export_intf_type
            )
        )
    end

    rule(:cflowd_monitoring_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg)
        )
      )
    end

    rule(:monitor_export_intf_type) do
      b(arg.as(:arg),
        c(
            a(str("engine-id"), arg),
            a(str("engine-type"), arg),
            a(str("input-interface-index"), arg),
            a(str("output-interface-index"), arg),
            b(str("source-address"),
              ipv4addr
            )
        )
      )
    end

    rule(:mpls_dialer_filter) do
      b(arg.as(:arg),
        c(
            a(str("accounting-profile"), arg),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            c(
                              a(str("exp"), arg),
                              a(str("exp-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            str("log"),
                            str("syslog"),
                            str("sample"),
                            c(
                              str("note"),
                              str("ignore")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:mpls_filter) do
      b(arg.as(:arg),
        c(
            a(str("accounting-profile"), arg),
            str("interface-specific"),
            str("physical-interface-filter"),
            str("instance-shared"),
            b(a(str("term"), arg),
                c(
                    a(str("filter"), arg),
                    b(str("from"),
                        c(
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            b(str("ip-version"),
                                c(
                                    b(str("ipv4"),
                                        c(
                                            a(str("protocol"), str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg,
                                                c(
                                                    c(
                                                      b(str("source-port"),
                                                            (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                                      ),
                                                      b(str("source-port-except"),
                                                            (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                                      )
                                                    ),
                                                    c(
                                                      b(str("destination-port"),
                                                            (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                                      ),
                                                      b(str("destination-port-except"),
                                                            (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                                      )
                                                    )
                                                )
                                            ),
                                            b(str("source-address"),
                                              firewall_addr_object
                                            ),
                                            b(str("destination-address"),
                                              firewall_addr_object
                                            ),
                                            b(str("source-prefix-list"),
                                              firewall_prefix_list
                                            ),
                                            b(str("destination-prefix-list"),
                                              firewall_prefix_list
                                            )
                                        )
                                    ),
                                    b(str("ipv6"),
                                        c(
                                            a(str("protocol"), str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg,
                                                c(
                                                    c(
                                                      b(str("source-port"),
                                                            (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                                      ),
                                                      b(str("source-port-except"),
                                                            (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                                      )
                                                    ),
                                                    c(
                                                      b(str("destination-port"),
                                                            (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                                      ),
                                                      b(str("destination-port-except"),
                                                            (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                                                      )
                                                    )
                                                )
                                            ),
                                            b(str("source-address"),
                                              firewall_addr6_object
                                            ),
                                            b(str("destination-address"),
                                              firewall_addr6_object
                                            ),
                                            b(str("source-prefix-list"),
                                              firewall_prefix_list
                                            ),
                                            b(str("destination-prefix-list"),
                                              firewall_prefix_list
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("label"), arg),
                            c(
                              a(str("exp"), arg),
                              a(str("exp-except"), arg)
                            ),
                            b(str("interface"),
                              match_interface_object
                            ),
                            b(str("interface-set"),
                              match_interface_set_object
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            c(
                              a(str("ttl"), arg),
                              a(str("ttl-except"), arg)
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            c(
                              b(str("flexible-match-mask"),
                                match_mpls_flexible_mask
                              )
                            ),
                            c(
                              b(str("flexible-match-range"),
                                match_mpls_flexible_range
                              )
                            ),
                            c(
                              a(str("policy-map"), arg),
                              a(str("policy-map-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("single-packet-rate"), arg),
                                        a(str("two-rate"), arg),
                                        a(str("two-packet-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            c(
                              str("clear-policy-map"),
                              a(str("policy-map"), arg)
                            ),
                            c(
                              a(str("traffic-class-count"), arg),
                              a(str("count"), arg)
                            ),
                            str("sample"),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("forwarding-class"), arg),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            str("packet-mode"),
                            c(
                              b(str("encapsulate"),
                                  sc(
                                      arg
                                  )
                              ).as(:oneline),
                              str("accept"),
                              str("discard"),
                              b(str("next"),
                                (str("term"))
                              )
                            )
                        )
                    ),
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:match_mpls_flexible_mask) do
        c(
            b(str("match-start"),
              (str("layer-3") | str("payload"))
            ),
            a(str("byte-offset"), arg),
            a(str("bit-offset"), arg),
            a(str("bit-length"), arg),
            a(str("mask-in-hex"), arg),
            a(str("prefix"), arg),
            a(str("flexible-mask-name"), arg)
        )
    end

    rule(:match_mpls_flexible_range) do
        c(
            b(str("match-start"),
              (str("layer-3") | str("payload"))
            ),
            a(str("byte-offset"), arg),
            a(str("bit-offset"), arg),
            a(str("bit-length"), arg),
            c(
              a(str("range"), arg),
              a(str("range-except"), arg)
            ),
            a(str("flexible-range-name"), arg)
        )
    end

    rule(:mpls_ifd_options) do
        c(
            b(str("pop-all-labels"),
                c(
                    b(str("required-depth"),
                      (str("all") | str("1") | str("2"))
                    )
                )
            )
        )
    end

    rule(:mpls_pm_family_output_type) do
        c(
            a(str("server-profile"), arg)
        )
    end

    rule(:mpls_template) do
      b(arg.as(:arg),
        c(
            b(str("attributes"),
                c(
                    str("exp"),
                    str("exp-except"),
                    str("flexible-match-mask"),
                    str("flexible-match-range"),
                    str("forwarding-class"),
                    str("forwarding-class-except"),
                    str("interface"),
                    str("interface-group"),
                    str("interface-set"),
                    str("loss-priority"),
                    str("loss-priority-except"),
                    str("label"),
                    str("ttl")
                )
            )
        )
      )
    end

    rule(:mrp_trace_options) do
        c(
            b(str("file"),
                sc(
                      arg,
                    str("replace"),
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("no-stamp"),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            a(str("flag"), enum(str("events") | str("pdu") | str("timers") | str("state-machine") | str("socket") | str("error") | str("all")),
                sc(
                    str("disable")
                )
            ).as(:oneline)
        )
    end

    rule(:mstp_interface) do
      b((str("all") | arg).as(:arg),
        c(
            a(str("priority"), arg),
            a(str("cost"), arg),
            b(str("mode"),
              (str("point-to-point") | str("shared"))
            ),
            str("edge"),
            str("access-trunk"),
            b(str("bpdu-timeout-action"),
                c(
                    str("block"),
                    str("alarm")
                )
            ),
            str("no-root-port"),
            str("disable")
        )
      )
    end

    rule(:multi_chassis_protection_group) do
      b(arg.as(:arg),
        c(
            a(str("interface"), arg)
        )
      )
    end

    rule(:multi_chassis_protection_group_ifl) do
      b(arg.as(:arg),
        c(
            a(str("interface"), arg)
        )
      )
    end

    rule(:multicast_interface_options_type) do
      b(arg.as(:arg),
        c(
            b(str("maximum-bandwidth"),
                sc(
                    arg
                )
            ).as(:oneline),
              (str("enable") | str("disable")),
            b(str("reverse-oif-mapping"),
                c(
                    str("no-qos-adjust")
                )
            ),
            a(str("subscriber-leave-timer"), arg),
            str("no-qos-adjust")
        )
      )
    end

    rule(:multilink_object) do
        c(
            a(str("fragment-threshold"), arg),
            a(str("drop-timeout"), arg)
        )
    end

    rule(:name_resolution_cache_type) do
        c(
            b(str("maximum-time-in-cache"),
                sc(
                    c(
                      str("unlimited"),
                        arg
                    )
                )
            ).as(:oneline),
            a(str("maximum-records-in-cache"), arg),
            a(str("blacklist-period"), arg),
            b(str("accelerations"),
                c(
                    str("no-refresh-before-ttl-expiry"),
                    str("initiate-next-queries"),
                    str("initiate-alternative-queries")
                )
            )
        )
    end

    rule(:nameserver_object) do
      b(arg.as(:arg),
        c(
            a(str("routing-instance"), arg),
            b(str("source-address"),
              ipaddr
            )
        )
      ).as(:oneline)
    end

    rule(:nasreq_definition) do
        c(
            b(a(str("partition"), arg),
                c(
                    a(str("diameter-instance"), arg),
                    a(str("destination-realm"), arg),
                    a(str("destination-host"), arg)
                )
            ),
            a(str("timeout"), arg),
            a(str("request-retry"), arg),
            a(str("max-outstanding-requests"), arg)
        )
    end

    rule(:nat_pool_object) do
      b(arg.as(:arg),
        c(
            b(str("pgcp"),
                c(
                    str("remotely-controlled"),
                    a(str("ports-per-session"), arg),
                    a(str("hint"), arg),
                      (str("tcp") | str("udp") | str("rtp-avp"))
                )
            ),
            a(str("address"), arg),
            b(str("interface"),
                sc(
                      interface_unit
                )
            ).as(:oneline),
            str("address-overload"),
            b(str("address-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg)
                )
            ).as(:oneline),
            b(str("port"),
                c(
                    c(
                      b(str("automatic"),
                          c(
                              c(
                                str("auto"),
                                str("sequential"),
                                str("random-allocation")
                              )
                          )
                      ),
                      b(str("range"),
                          sc(
                              a(str("low"), arg),
                              a(str("high"), arg),
                              str("random-allocation")
                          )
                      ).as(:oneline)
                    ),
                    c(
                      b(str("secured-port-block-allocation"),
                          sc(
                              a(str("block-size"), arg),
                              a(str("max-blocks-per-address"), arg),
                              a(str("active-block-timeout"), arg)
                          )
                      ).as(:oneline),
                      b(str("deterministic-port-block-allocation"),
                          sc(
                              a(str("block-size"), arg),
                              str("include-boundary-addresses")
                          )
                      ).as(:oneline)
                    ),
                    str("preserve-parity"),
                    str("preserve-range")
                )
            ),
            b(str("address-allocation"),
                c(
                    str("round-robin")
                )
            ),
            a(str("mapping-timeout"), arg),
            a(str("flow-timeout"), arg),
            a(str("ei-mapping-timeout"), arg),
            a(str("app-mapping-timeout"), arg),
            a(str("limit-ports-per-address"), arg),
            b(str("snmp-trap-thresholds"),
                c(
                    b(str("address-port"),
                        sc(
                            a(str("low"), arg),
                            a(str("high"), arg)
                        )
                    ).as(:oneline)
                )
            )
        )
      )
    end

    rule(:nat_rule_object) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("input") | str("output") | str("input-output"))
            ),
            b(a(str("term"), arg),
                c(
                    b(str("nat-type"),
                      (str("symmetric") | str("full-cone"))
                    ),
                    b(str("from"),
                      sfw_match_object
                    ),
                    b(str("then"),
                        c(
                            c(
                              str("no-translation")
                            ),
                            c(
                              a(str("port-forwarding-mappings"), arg)
                            ),
                            b(str("translated"),
                                c(
                                    c(
                                      a(str("source-pool"), arg),
                                      b(str("source-prefix"),
                                        ipprefix_only
                                      )
                                    ),
                                    b(str("clat-prefix"),
                                      ipprefix_only
                                    ),
                                    c(
                                      a(str("destination-pool"), arg),
                                      b(str("destination-prefix"),
                                        ipprefix_only
                                      )
                                    ),
                                    c(
                                      a(str("dns-alg-pool"), arg),
                                      b(str("dns-alg-prefix"),
                                        ipprefix_only
                                      )
                                    ),
                                    c(
                                      str("use-dns-map-for-destination-translation")
                                    ),
                                    c(
                                      a(str("overload-pool"), arg),
                                      b(str("overload-prefix"),
                                        ipprefix_only
                                      )
                                    ),
                                    b(str("translation-type"),
                                        c(
                                            b(str("source"),
                                              (str("static") | str("dynamic"))
                                            ),
                                            b(str("destination"),
                                              (str("static"))
                                            ),
                                            str("basic-nat44"),
                                            str("dynamic-nat44"),
                                            str("napt-44"),
                                            str("dnat-44"),
                                            str("stateful-nat64"),
                                            str("stateful-nat464"),
                                            str("basic-nat-pt"),
                                            str("napt-pt"),
                                            str("basic-nat66"),
                                            str("nptv6"),
                                            str("napt-66"),
                                            str("twice-napt-44"),
                                            str("twice-basic-nat-44"),
                                            str("twice-dynamic-nat-44"),
                                            str("deterministic-napt44"),
                                            str("deterministic-napt64")
                                        )
                                    ),
                                    b(str("mapping-type"),
                                      (str("endpoint-independent"))
                                    ),
                                    b(str("flow-type"),
                                      (str("endpoint-independent"))
                                    ),
                                    str("ignore-dst-nat-1to1-limitation"),
                                    b(str("secure-nat-mapping"),
                                        c(
                                            a(str("eif-flow-limit"), arg),
                                            b(str("mapping-refresh"),
                                              (str("inbound") | str("outbound") | str("inbound-outbound"))
                                            ),
                                            b(str("flow-refresh"),
                                              (str("inbound") | str("outbound") | str("inbound-outbound"))
                                            )
                                        )
                                    ),
                                    b(str("filtering-type"),
                                        c(
                                            b(str("endpoint-independent"),
                                                c(
                                                    b(a(str("prefix-list"), arg),
                                                        sc(
                                                            str("except")
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("address-pooling"),
                                      (str("paired"))
                                    )
                                )
                            ),
                            str("syslog")
                        )
                    )
                )
            )
        )
      )
    end

    rule(:network_type) do
      arg.as(:arg)
    end

    rule(:new_call_then_type) do
        c(
            str("trace"),
            b(str("media-policy"),
                c(
                    c(
                      str("no-anchoring"),
                      str("media-release")
                    ),
                    b(str("nat-traversal"),
                        c(
                            b(str("nat-traversal-strategy"),
                              (str("never") | str("always") | str("same-as-signaling"))
                            ),
                            str("force-bidirectional-media")
                        )
                    ),
                    b(str("data-inactivity-detection"),
                        c(
                            a(str("inactivity-duration"), arg)
                        )
                    ),
                    a(str("service-class"), arg)
                )
            )
        )
    end

    rule(:new_call_usage_set_type) do
      b(arg.as(:arg),
        c(
              arg
        )
      )
    end

    rule(:new_registration_set_type) do
      b(arg.as(:arg),
        c(
              arg
        )
      )
    end

    rule(:new_transaction_set_type) do
      b(arg.as(:arg),
        c(
              arg
        )
      )
    end

    rule(:next_hop_group_intf_type) do
      b(arg.as(:arg),
        c(
            b(str("next-hop"),
              next_hop_type
            )
        )
      )
    end

    rule(:next_hop_subgroup_intf_type) do
      b(arg.as(:arg),
        c(
            b(str("next-hop"),
              next_hop_type
            )
        )
      )
    end

    rule(:next_hop_type) do
      arg.as(:arg)
    end

    rule(:och_attributes) do
        c(
            b(str("rate"),
              (str("100g"))
            ),
            b(str("modulation"),
              (str("qpsk"))
            ),
            b(str("encoding"),
              (str("differential"))
            ),
            c(
              b(str("wavelength"),
                (str("1568.77") | str("1568.36") | str("1568.31") | str("1568.26") | str("1568.21") | str("1568.16") | str("1568.11") | str("1568.05") | str("1568.00") | str("1567.95") | str("1567.90") | str("1567.85") | str("1567.80") | str("1567.75") | str("1567.70") | str("1567.64") | str("1567.59") | str("1567.54") | str("1567.49") | str("1567.44") | str("1567.39") | str("1567.34") | str("1567.29") | str("1567.23") | str("1567.18") | str("1567.13") | str("1567.08") | str("1567.03") | str("1566.98") | str("1566.93") | str("1566.88") | str("1566.83") | str("1566.77") | str("1566.72") | str("1566.67") | str("1566.62") | str("1566.57") | str("1566.52") | str("1566.47") | str("1566.42") | str("1566.36") | str("1566.31") | str("1566.26") | str("1566.21") | str("1566.16") | str("1566.11") | str("1566.06") | str("1566.01") | str("1565.96") | str("1565.90") | str("1565.85") | str("1565.80") | str("1565.75") | str("1565.70") | str("1565.65") | str("1565.60") | str("1565.55") | str("1565.50") | str("1565.44") | str("1565.39") | str("1565.34") | str("1565.29") | str("1565.24") | str("1565.19") | str("1565.14") | str("1565.09") | str("1565.04") | str("1564.99") | str("1564.93") | str("1564.88") | str("1564.83") | str("1564.78") | str("1564.73") | str("1564.68") | str("1564.63") | str("1564.58") | str("1564.53") | str("1564.47") | str("1564.42") | str("1564.37") | str("1564.32") | str("1564.27") | str("1564.22") | str("1564.17") | str("1564.12") | str("1564.07") | str("1564.02") | str("1563.96") | str("1563.91") | str("1563.86") | str("1563.81") | str("1563.76") | str("1563.71") | str("1563.66") | str("1563.61") | str("1563.56") | str("1563.51") | str("1563.45") | str("1563.40") | str("1563.35") | str("1563.30") | str("1563.25") | str("1563.20") | str("1563.15") | str("1563.10") | str("1563.05") | str("1563.00") | str("1562.95") | str("1562.89") | str("1562.84") | str("1562.79") | str("1562.74") | str("1562.69") | str("1562.64") | str("1562.59") | str("1562.54") | str("1562.49") | str("1562.44") | str("1562.39") | str("1562.33") | str("1562.28") | str("1562.23") | str("1562.18") | str("1562.13") | str("1562.08") | str("1562.03") | str("1561.98") | str("1561.93") | str("1561.88") | str("1561.83") | str("1561.77") | str("1561.72") | str("1561.67") | str("1561.62") | str("1561.57") | str("1561.52") | str("1561.47") | str("1561.42") | str("1561.37") | str("1561.32") | str("1561.27") | str("1561.22") | str("1561.16") | str("1561.11") | str("1561.06") | str("1561.01") | str("1560.96") | str("1560.91") | str("1560.86") | str("1560.81") | str("1560.76") | str("1560.71") | str("1560.66") | str("1560.61") | str("1560.56") | str("1560.50") | str("1560.45") | str("1560.40") | str("1560.35") | str("1560.30") | str("1560.25") | str("1560.20") | str("1560.15") | str("1560.10") | str("1560.05") | str("1560.00") | str("1559.95") | str("1559.90") | str("1559.84") | str("1559.79") | str("1559.74") | str("1559.69") | str("1559.64") | str("1559.59") | str("1559.54") | str("1559.49") | str("1559.44") | str("1559.39") | str("1559.34") | str("1559.29") | str("1559.24") | str("1559.19") | str("1559.14") | str("1559.08") | str("1559.03") | str("1558.98") | str("1558.93") | str("1558.88") | str("1558.83") | str("1558.78") | str("1558.73") | str("1558.68") | str("1558.63") | str("1558.58") | str("1558.53") | str("1558.48") | str("1558.43") | str("1558.38") | str("1558.32") | str("1558.27") | str("1558.22") | str("1558.17") | str("1558.12") | str("1558.07") | str("1558.02") | str("1557.97") | str("1557.92") | str("1557.87") | str("1557.82") | str("1557.77") | str("1557.72") | str("1557.67") | str("1557.62") | str("1557.57") | str("1557.52") | str("1557.46") | str("1557.41") | str("1557.36") | str("1557.31") | str("1557.26") | str("1557.21") | str("1557.16") | str("1557.11") | str("1557.06") | str("1557.01") | str("1556.96") | str("1556.91") | str("1556.86") | str("1556.81") | str("1556.76") | str("1556.71") | str("1556.66") | str("1556.61") | str("1556.55") | str("1556.50") | str("1556.45") | str("1556.40") | str("1556.35") | str("1556.30") | str("1556.25") | str("1556.20") | str("1556.15") | str("1556.10") | str("1556.05") | str("1556.00") | str("1555.95") | str("1555.90") | str("1555.85") | str("1555.80") | str("1555.75") | str("1555.70") | str("1555.65") | str("1555.60") | str("1555.55") | str("1555.49") | str("1555.44") | str("1555.39") | str("1555.34") | str("1555.29") | str("1555.24") | str("1555.19") | str("1555.14") | str("1555.09") | str("1555.04") | str("1554.99") | str("1554.94") | str("1554.89") | str("1554.84") | str("1554.79") | str("1554.74") | str("1554.69") | str("1554.64") | str("1554.59") | str("1554.54") | str("1554.49") | str("1554.44") | str("1554.39") | str("1554.34") | str("1554.29") | str("1554.23") | str("1554.18") | str("1554.13") | str("1554.08") | str("1554.03") | str("1553.98") | str("1553.93") | str("1553.88") | str("1553.83") | str("1553.78") | str("1553.73") | str("1553.68") | str("1553.63") | str("1553.58") | str("1553.53") | str("1553.48") | str("1553.43") | str("1553.38") | str("1553.33") | str("1553.28") | str("1553.23") | str("1553.18") | str("1553.13") | str("1553.08") | str("1553.03") | str("1552.98") | str("1552.93") | str("1552.88") | str("1552.83") | str("1552.78") | str("1552.73") | str("1552.68") | str("1552.62") | str("1552.57") | str("1552.52") | str("1552.47") | str("1552.42") | str("1552.37") | str("1552.32") | str("1552.27") | str("1552.22") | str("1552.17") | str("1552.12") | str("1552.07") | str("1552.02") | str("1551.97") | str("1551.92") | str("1551.87") | str("1551.82") | str("1551.77") | str("1551.72") | str("1551.67") | str("1551.62") | str("1551.57") | str("1551.52") | str("1551.47") | str("1551.42") | str("1551.37") | str("1551.32") | str("1551.27") | str("1551.22") | str("1551.17") | str("1551.12") | str("1551.07") | str("1551.02") | str("1550.97") | str("1550.92") | str("1550.87") | str("1550.82") | str("1550.77") | str("1550.72") | str("1550.67") | str("1550.62") | str("1550.57") | str("1550.52") | str("1550.47") | str("1550.42") | str("1550.37") | str("1550.32") | str("1550.27") | str("1550.22") | str("1550.17") | str("1550.12") | str("1550.07") | str("1550.02") | str("1549.97") | str("1549.92") | str("1549.87") | str("1549.82") | str("1549.77") | str("1549.72") | str("1549.67") | str("1549.62") | str("1549.57") | str("1549.52") | str("1549.47") | str("1549.42") | str("1549.37") | str("1549.32") | str("1549.26") | str("1549.21") | str("1549.16") | str("1549.11") | str("1549.06") | str("1549.01") | str("1548.96") | str("1548.91") | str("1548.86") | str("1548.81") | str("1548.76") | str("1548.71") | str("1548.66") | str("1548.61") | str("1548.56") | str("1548.51") | str("1548.46") | str("1548.41") | str("1548.36") | str("1548.31") | str("1548.26") | str("1548.21") | str("1548.16") | str("1548.11") | str("1548.06") | str("1548.02") | str("1547.97") | str("1547.92") | str("1547.87") | str("1547.82") | str("1547.77") | str("1547.72") | str("1547.67") | str("1547.62") | str("1547.57") | str("1547.52") | str("1547.47") | str("1547.42") | str("1547.37") | str("1547.32") | str("1547.27") | str("1547.22") | str("1547.17") | str("1547.12") | str("1547.07") | str("1547.02") | str("1546.97") | str("1546.92") | str("1546.87") | str("1546.82") | str("1546.77") | str("1546.72") | str("1546.67") | str("1546.62") | str("1546.57") | str("1546.52") | str("1546.47") | str("1546.42") | str("1546.37") | str("1546.32") | str("1546.27") | str("1546.22") | str("1546.17") | str("1546.12") | str("1546.07") | str("1546.02") | str("1545.97") | str("1545.92") | str("1545.87") | str("1545.82") | str("1545.77") | str("1545.72") | str("1545.67") | str("1545.62") | str("1545.57") | str("1545.52") | str("1545.47") | str("1545.42") | str("1545.37") | str("1545.32") | str("1545.27") | str("1545.22") | str("1545.17") | str("1545.12") | str("1545.07") | str("1545.02") | str("1544.97") | str("1544.92") | str("1544.87") | str("1544.82") | str("1544.77") | str("1544.72") | str("1544.68") | str("1544.63") | str("1544.58") | str("1544.53") | str("1544.48") | str("1544.43") | str("1544.38") | str("1544.33") | str("1544.28") | str("1544.23") | str("1544.18") | str("1544.13") | str("1544.08") | str("1544.03") | str("1543.98") | str("1543.93") | str("1543.88") | str("1543.83") | str("1543.78") | str("1543.73") | str("1543.68") | str("1543.63") | str("1543.58") | str("1543.53") | str("1543.48") | str("1543.43") | str("1543.38") | str("1543.33") | str("1543.28") | str("1543.23") | str("1543.18") | str("1543.13") | str("1543.08") | str("1543.04") | str("1542.99") | str("1542.94") | str("1542.89") | str("1542.84") | str("1542.79") | str("1542.74") | str("1542.69") | str("1542.64") | str("1542.59") | str("1542.54") | str("1542.49") | str("1542.44") | str("1542.39") | str("1542.34") | str("1542.29") | str("1542.24") | str("1542.19") | str("1542.14") | str("1542.09") | str("1542.04") | str("1541.99") | str("1541.94") | str("1541.89") | str("1541.84") | str("1541.80") | str("1541.75") | str("1541.70") | str("1541.65") | str("1541.60") | str("1541.55") | str("1541.50") | str("1541.45") | str("1541.40") | str("1541.35") | str("1541.30") | str("1541.25") | str("1541.20") | str("1541.15") | str("1541.10") | str("1541.05") | str("1541.00") | str("1540.95") | str("1540.90") | str("1540.85") | str("1540.80") | str("1540.76") | str("1540.71") | str("1540.66") | str("1540.61") | str("1540.56") | str("1540.51") | str("1540.46") | str("1540.41") | str("1540.36") | str("1540.31") | str("1540.26") | str("1540.21") | str("1540.16") | str("1540.11") | str("1540.06") | str("1540.01") | str("1539.96") | str("1539.91") | str("1539.86") | str("1539.82") | str("1539.77") | str("1539.72") | str("1539.67") | str("1539.62") | str("1539.57") | str("1539.52") | str("1539.47") | str("1539.42") | str("1539.37") | str("1539.32") | str("1539.27") | str("1539.22") | str("1539.17") | str("1539.12") | str("1539.07") | str("1539.03") | str("1538.98") | str("1538.93") | str("1538.88") | str("1538.83") | str("1538.78") | str("1538.73") | str("1538.68") | str("1538.63") | str("1538.58") | str("1538.53") | str("1538.48") | str("1538.43") | str("1538.38") | str("1538.33") | str("1538.28") | str("1538.24") | str("1538.19") | str("1538.14") | str("1538.09") | str("1538.04") | str("1537.99") | str("1537.94") | str("1537.89") | str("1537.84") | str("1537.79") | str("1537.74") | str("1537.69") | str("1537.64") | str("1537.59") | str("1537.55") | str("1537.50") | str("1537.45") | str("1537.40") | str("1537.35") | str("1537.30") | str("1537.25") | str("1537.20") | str("1537.15") | str("1537.10") | str("1537.05") | str("1537.00") | str("1536.95") | str("1536.90") | str("1536.86") | str("1536.81") | str("1536.76") | str("1536.71") | str("1536.66") | str("1536.61") | str("1536.56") | str("1536.51") | str("1536.46") | str("1536.41") | str("1536.36") | str("1536.31") | str("1536.26") | str("1536.22") | str("1536.17") | str("1536.12") | str("1536.07") | str("1536.02") | str("1535.97") | str("1535.92") | str("1535.87") | str("1535.82") | str("1535.77") | str("1535.72") | str("1535.67") | str("1535.63") | str("1535.58") | str("1535.53") | str("1535.48") | str("1535.43") | str("1535.38") | str("1535.33") | str("1535.28") | str("1535.23") | str("1535.18") | str("1535.13") | str("1535.08") | str("1535.04") | str("1534.99") | str("1534.94") | str("1534.89") | str("1534.84") | str("1534.79") | str("1534.74") | str("1534.69") | str("1534.64") | str("1534.59") | str("1534.54") | str("1534.50") | str("1534.45") | str("1534.40") | str("1534.35") | str("1534.30") | str("1534.25") | str("1534.20") | str("1534.15") | str("1534.10") | str("1534.05") | str("1534.00") | str("1533.96") | str("1533.91") | str("1533.86") | str("1533.81") | str("1533.76") | str("1533.71") | str("1533.66") | str("1533.61") | str("1533.56") | str("1533.51") | str("1533.47") | str("1533.42") | str("1533.37") | str("1533.32") | str("1533.27") | str("1533.22") | str("1533.17") | str("1533.12") | str("1533.07") | str("1533.02") | str("1532.98") | str("1532.93") | str("1532.88") | str("1532.83") | str("1532.78") | str("1532.73") | str("1532.68") | str("1532.63") | str("1532.58") | str("1532.53") | str("1532.49") | str("1532.44") | str("1532.39") | str("1532.34") | str("1532.29") | str("1532.24") | str("1532.19") | str("1532.14") | str("1532.09") | str("1532.04") | str("1532.00") | str("1531.95") | str("1531.90") | str("1531.85") | str("1531.80") | str("1531.75") | str("1531.70") | str("1531.65") | str("1531.60") | str("1531.56") | str("1531.51") | str("1531.46") | str("1531.41") | str("1531.36") | str("1531.31") | str("1531.26") | str("1531.21") | str("1531.16") | str("1531.12") | str("1531.07") | str("1531.02") | str("1530.97") | str("1530.92") | str("1530.87") | str("1530.82") | str("1530.77") | str("1530.72") | str("1530.68") | str("1530.63") | str("1530.58") | str("1530.53") | str("1530.48") | str("1530.43") | str("1530.38") | str("1530.33") | str("1530.29") | str("1530.24") | str("1530.19") | str("1530.14") | str("1530.09") | str("1530.04") | str("1529.99") | str("1529.94") | str("1529.89") | str("1529.85") | str("1529.80") | str("1529.75") | str("1529.70") | str("1529.65") | str("1529.60") | str("1529.55") | str("1529.50") | str("1529.46") | str("1529.41") | str("1529.36") | str("1529.31") | str("1529.26") | str("1529.21") | str("1529.16") | str("1529.11") | str("1529.07") | str("1529.02") | str("1528.97") | str("1528.92") | str("1528.87") | str("1528.82") | str("1528.77") | str("1528.38"))
              ),
              b(str("frequency"),
                (str("191.1003") | str("191.15000") | str("191.15625") | str("191.16250") | str("191.16875") | str("191.17500") | str("191.18125") | str("191.18750") | str("191.19375") | str("191.20000") | str("191.20625") | str("191.21250") | str("191.21875") | str("191.22500") | str("191.23125") | str("191.23750") | str("191.24375") | str("191.25000") | str("191.25625") | str("191.26250") | str("191.26875") | str("191.27500") | str("191.28125") | str("191.28750") | str("191.29375") | str("191.30000") | str("191.30625") | str("191.31250") | str("191.31875") | str("191.32500") | str("191.33125") | str("191.33750") | str("191.34375") | str("191.35000") | str("191.35625") | str("191.36250") | str("191.36875") | str("191.37500") | str("191.38125") | str("191.38750") | str("191.39375") | str("191.40000") | str("191.40625") | str("191.41250") | str("191.41875") | str("191.42500") | str("191.43125") | str("191.43750") | str("191.44375") | str("191.45000") | str("191.45625") | str("191.46250") | str("191.46875") | str("191.47500") | str("191.48125") | str("191.48750") | str("191.49375") | str("191.50000") | str("191.50625") | str("191.51250") | str("191.51875") | str("191.52500") | str("191.53125") | str("191.53750") | str("191.54375") | str("191.55000") | str("191.55625") | str("191.56250") | str("191.56875") | str("191.57500") | str("191.58125") | str("191.58750") | str("191.59375") | str("191.60000") | str("191.60625") | str("191.61250") | str("191.61875") | str("191.62500") | str("191.63125") | str("191.63750") | str("191.64375") | str("191.65000") | str("191.65625") | str("191.66250") | str("191.66875") | str("191.67500") | str("191.68125") | str("191.68750") | str("191.69375") | str("191.70000") | str("191.70625") | str("191.71250") | str("191.71875") | str("191.72500") | str("191.73125") | str("191.73750") | str("191.74375") | str("191.75000") | str("191.75625") | str("191.76250") | str("191.76875") | str("191.77500") | str("191.78125") | str("191.78750") | str("191.79375") | str("191.80000") | str("191.80625") | str("191.81250") | str("191.81875") | str("191.82500") | str("191.83125") | str("191.83750") | str("191.84375") | str("191.85000") | str("191.85625") | str("191.86250") | str("191.86875") | str("191.87500") | str("191.88125") | str("191.88750") | str("191.89375") | str("191.90000") | str("191.90625") | str("191.91250") | str("191.91875") | str("191.92500") | str("191.93125") | str("191.93750") | str("191.94375") | str("191.95000") | str("191.95625") | str("191.96250") | str("191.96875") | str("191.97500") | str("191.98125") | str("191.98750") | str("191.99375") | str("192.00000") | str("192.00625") | str("192.01250") | str("192.01875") | str("192.02500") | str("192.03125") | str("192.03750") | str("192.04375") | str("192.05000") | str("192.05625") | str("192.06250") | str("192.06875") | str("192.07500") | str("192.08125") | str("192.08750") | str("192.09375") | str("192.10000") | str("192.10625") | str("192.11250") | str("192.11875") | str("192.12500") | str("192.13125") | str("192.13750") | str("192.14375") | str("192.15000") | str("192.15625") | str("192.16250") | str("192.16875") | str("192.17500") | str("192.18125") | str("192.18750") | str("192.19375") | str("192.20000") | str("192.20625") | str("192.21250") | str("192.21875") | str("192.22500") | str("192.23125") | str("192.23750") | str("192.24375") | str("192.25000") | str("192.25625") | str("192.26250") | str("192.26875") | str("192.27500") | str("192.28125") | str("192.28750") | str("192.29375") | str("192.30000") | str("192.30625") | str("192.31250") | str("192.31875") | str("192.32500") | str("192.33125") | str("192.33750") | str("192.34375") | str("192.35000") | str("192.35625") | str("192.36250") | str("192.36875") | str("192.37500") | str("192.38125") | str("192.38750") | str("192.39375") | str("192.40000") | str("192.40625") | str("192.41250") | str("192.41875") | str("192.42500") | str("192.43125") | str("192.43750") | str("192.44375") | str("192.45000") | str("192.45625") | str("192.46250") | str("192.46875") | str("192.47500") | str("192.48125") | str("192.48750") | str("192.49375") | str("192.50000") | str("192.50625") | str("192.51250") | str("192.51875") | str("192.52500") | str("192.53125") | str("192.53750") | str("192.54375") | str("192.55000") | str("192.55625") | str("192.56250") | str("192.56875") | str("192.57500") | str("192.58125") | str("192.58750") | str("192.59375") | str("192.60000") | str("192.60625") | str("192.61250") | str("192.61875") | str("192.62500") | str("192.63125") | str("192.63750") | str("192.64375") | str("192.65000") | str("192.65625") | str("192.66250") | str("192.66875") | str("192.67500") | str("192.68125") | str("192.68750") | str("192.69375") | str("192.70000") | str("192.70625") | str("192.71250") | str("192.71875") | str("192.72500") | str("192.73125") | str("192.73750") | str("192.74375") | str("192.75000") | str("192.75625") | str("192.76250") | str("192.76875") | str("192.77500") | str("192.78125") | str("192.78750") | str("192.79375") | str("192.80000") | str("192.80625") | str("192.81250") | str("192.81875") | str("192.82500") | str("192.83125") | str("192.83750") | str("192.84375") | str("192.85000") | str("192.85625") | str("192.86250") | str("192.86875") | str("192.87500") | str("192.88125") | str("192.88750") | str("192.89375") | str("192.90000") | str("192.90625") | str("192.91250") | str("192.91875") | str("192.92500") | str("192.93125") | str("192.93750") | str("192.94375") | str("192.95000") | str("192.95625") | str("192.96250") | str("192.96875") | str("192.97500") | str("192.98125") | str("192.98750") | str("192.99375") | str("193.00000") | str("193.00625") | str("193.01250") | str("193.01875") | str("193.02500") | str("193.03125") | str("193.03750") | str("193.04375") | str("193.05000") | str("193.05625") | str("193.06250") | str("193.06875") | str("193.07500") | str("193.08125") | str("193.08750") | str("193.09375") | str("193.10000") | str("193.10625") | str("193.11250") | str("193.11875") | str("193.12500") | str("193.13125") | str("193.13750") | str("193.14375") | str("193.15000") | str("193.15625") | str("193.16250") | str("193.16875") | str("193.17500") | str("193.18125") | str("193.18750") | str("193.19375") | str("193.20000") | str("193.20625") | str("193.21250") | str("193.21875") | str("193.22500") | str("193.23125") | str("193.23750") | str("193.24375") | str("193.25000") | str("193.25625") | str("193.26250") | str("193.26875") | str("193.27500") | str("193.28125") | str("193.28750") | str("193.29375") | str("193.30000") | str("193.30625") | str("193.31250") | str("193.31875") | str("193.32500") | str("193.33125") | str("193.33750") | str("193.34375") | str("193.35000") | str("193.35625") | str("193.36250") | str("193.36875") | str("193.37500") | str("193.38125") | str("193.38750") | str("193.39375") | str("193.40000") | str("193.40625") | str("193.41250") | str("193.41875") | str("193.42500") | str("193.43125") | str("193.43750") | str("193.44375") | str("193.45000") | str("193.45625") | str("193.46250") | str("193.46875") | str("193.47500") | str("193.48125") | str("193.48750") | str("193.49375") | str("193.50000") | str("193.50625") | str("193.51250") | str("193.51875") | str("193.52500") | str("193.53125") | str("193.53750") | str("193.54375") | str("193.55000") | str("193.55625") | str("193.56250") | str("193.56875") | str("193.57500") | str("193.58125") | str("193.58750") | str("193.59375") | str("193.60000") | str("193.60625") | str("193.61250") | str("193.61875") | str("193.62500") | str("193.63125") | str("193.63750") | str("193.64375") | str("193.65000") | str("193.65625") | str("193.66250") | str("193.66875") | str("193.67500") | str("193.68125") | str("193.68750") | str("193.69375") | str("193.70000") | str("193.70625") | str("193.71250") | str("193.71875") | str("193.72500") | str("193.73125") | str("193.73750") | str("193.74375") | str("193.75000") | str("193.75625") | str("193.76250") | str("193.76875") | str("193.77500") | str("193.78125") | str("193.78750") | str("193.79375") | str("193.80000") | str("193.80625") | str("193.81250") | str("193.81875") | str("193.82500") | str("193.83125") | str("193.83750") | str("193.84375") | str("193.85000") | str("193.85625") | str("193.86250") | str("193.86875") | str("193.87500") | str("193.88125") | str("193.88750") | str("193.89375") | str("193.90000") | str("193.90625") | str("193.91250") | str("193.91875") | str("193.92500") | str("193.93125") | str("193.93750") | str("193.94375") | str("193.95000") | str("193.95625") | str("193.96250") | str("193.96875") | str("193.97500") | str("193.98125") | str("193.98750") | str("193.99375") | str("194.00000") | str("194.00625") | str("194.01250") | str("194.01875") | str("194.02500") | str("194.03125") | str("194.03750") | str("194.04375") | str("194.05000") | str("194.05625") | str("194.06250") | str("194.06875") | str("194.07500") | str("194.08125") | str("194.08750") | str("194.09375") | str("194.10000") | str("194.10625") | str("194.11250") | str("194.11875") | str("194.12500") | str("194.13125") | str("194.13750") | str("194.14375") | str("194.15000") | str("194.15625") | str("194.16250") | str("194.16875") | str("194.17500") | str("194.18125") | str("194.18750") | str("194.19375") | str("194.20000") | str("194.20625") | str("194.21250") | str("194.21875") | str("194.22500") | str("194.23125") | str("194.23750") | str("194.24375") | str("194.25000") | str("194.25625") | str("194.26250") | str("194.26875") | str("194.27500") | str("194.28125") | str("194.28750") | str("194.29375") | str("194.30000") | str("194.30625") | str("194.31250") | str("194.31875") | str("194.32500") | str("194.33125") | str("194.33750") | str("194.34375") | str("194.35000") | str("194.35625") | str("194.36250") | str("194.36875") | str("194.37500") | str("194.38125") | str("194.38750") | str("194.39375") | str("194.40000") | str("194.40625") | str("194.41250") | str("194.41875") | str("194.42500") | str("194.43125") | str("194.43750") | str("194.44375") | str("194.45000") | str("194.45625") | str("194.46250") | str("194.46875") | str("194.47500") | str("194.48125") | str("194.48750") | str("194.49375") | str("194.50000") | str("194.50625") | str("194.51250") | str("194.51875") | str("194.52500") | str("194.53125") | str("194.53750") | str("194.54375") | str("194.55000") | str("194.55625") | str("194.56250") | str("194.56875") | str("194.57500") | str("194.58125") | str("194.58750") | str("194.59375") | str("194.60000") | str("194.60625") | str("194.61250") | str("194.61875") | str("194.62500") | str("194.63125") | str("194.63750") | str("194.64375") | str("194.65000") | str("194.65625") | str("194.66250") | str("194.66875") | str("194.67500") | str("194.68125") | str("194.68750") | str("194.69375") | str("194.70000") | str("194.70625") | str("194.71250") | str("194.71875") | str("194.72500") | str("194.73125") | str("194.73750") | str("194.74375") | str("194.75000") | str("194.75625") | str("194.76250") | str("194.76875") | str("194.77500") | str("194.78125") | str("194.78750") | str("194.79375") | str("194.80000") | str("194.80625") | str("194.81250") | str("194.81875") | str("194.82500") | str("194.83125") | str("194.83750") | str("194.84375") | str("194.85000") | str("194.85625") | str("194.86250") | str("194.86875") | str("194.87500") | str("194.88125") | str("194.88750") | str("194.89375") | str("194.90000") | str("194.90625") | str("194.91250") | str("194.91875") | str("194.92500") | str("194.93125") | str("194.93750") | str("194.94375") | str("194.95000") | str("194.95625") | str("194.96250") | str("194.96875") | str("194.97500") | str("194.98125") | str("194.98750") | str("194.99375") | str("195.00000") | str("195.00625") | str("195.01250") | str("195.01875") | str("195.02500") | str("195.03125") | str("195.03750") | str("195.04375") | str("195.05000") | str("195.05625") | str("195.06250") | str("195.06875") | str("195.07500") | str("195.08125") | str("195.08750") | str("195.09375") | str("195.10000") | str("195.10625") | str("195.11250") | str("195.11875") | str("195.12500") | str("195.13125") | str("195.13750") | str("195.14375") | str("195.15000") | str("195.15625") | str("195.16250") | str("195.16875") | str("195.17500") | str("195.18125") | str("195.18750") | str("195.19375") | str("195.20000") | str("195.20625") | str("195.21250") | str("195.21875") | str("195.22500") | str("195.23125") | str("195.23750") | str("195.24375") | str("195.25000") | str("195.25625") | str("195.26250") | str("195.26875") | str("195.27500") | str("195.28125") | str("195.28750") | str("195.29375") | str("195.30000") | str("195.30625") | str("195.31250") | str("195.31875") | str("195.32500") | str("195.33125") | str("195.33750") | str("195.34375") | str("195.35000") | str("195.35625") | str("195.36250") | str("195.36875") | str("195.37500") | str("195.38125") | str("195.38750") | str("195.39375") | str("195.40000") | str("195.40625") | str("195.41250") | str("195.41875") | str("195.42500") | str("195.43125") | str("195.43750") | str("195.44375") | str("195.45000") | str("195.45625") | str("195.46250") | str("195.46875") | str("195.47500") | str("195.48125") | str("195.48750") | str("195.49375") | str("195.50000") | str("195.50625") | str("195.51250") | str("195.51875") | str("195.52500") | str("195.53125") | str("195.53750") | str("195.54375") | str("195.55000") | str("195.55625") | str("195.56250") | str("195.56875") | str("195.57500") | str("195.58125") | str("195.58750") | str("195.59375") | str("195.60000") | str("195.60625") | str("195.61250") | str("195.61875") | str("195.62500") | str("195.63125") | str("195.63750") | str("195.64375") | str("195.65000") | str("195.65625") | str("195.66250") | str("195.66875") | str("195.67500") | str("195.68125") | str("195.68750") | str("195.69375") | str("195.70000") | str("195.70625") | str("195.71250") | str("195.71875") | str("195.72500") | str("195.73125") | str("195.73750") | str("195.74375") | str("195.75000") | str("195.75625") | str("195.76250") | str("195.76875") | str("195.77500") | str("195.78125") | str("195.78750") | str("195.79375") | str("195.80000") | str("195.80625") | str("195.81250") | str("195.81875") | str("195.82500") | str("195.83125") | str("195.83750") | str("195.84375") | str("195.85000") | str("195.85625") | str("195.86250") | str("195.86875") | str("195.87500") | str("195.88125") | str("195.88750") | str("195.89375") | str("195.90000") | str("195.90625") | str("195.91250") | str("195.91875") | str("195.92500") | str("195.93125") | str("195.93750") | str("195.94375") | str("195.95000") | str("195.95625") | str("195.96250") | str("195.96875") | str("195.97500") | str("195.98125") | str("195.98750") | str("195.99375") | str("196.00000") | str("196.00625") | str("196.01250") | str("196.01875") | str("196.02500") | str("196.03125") | str("196.03750") | str("196.04375") | str("196.05000") | str("196.05625") | str("196.06250") | str("196.06875") | str("196.07500") | str("196.08125") | str("196.08750") | str("196.09375") | str("196.10000") | str("196.15040"))
              )
            ),
            a(str("tx-power"), arg),
            str("laser-enable"),
            str("no-laser-enable")
        )
    end

    rule(:ocs_definition) do
        c(
            b(a(str("partition"), arg),
                c(
                    a(str("alternative-partition-name"), arg),
                    a(str("called-station-id"), arg),
                    b(str("backup"),
                        c(
                            a(str("limit"), arg),
                            b(str("overflow"),
                              (str("deny-login") | str("drop-oldest"))
                            ),
                            a(str("timeout"), arg)
                        )
                    ),
                    a(str("charging-id"), arg),
                    a(str("destination-realm"), arg),
                    a(str("destination-host"), arg),
                    a(str("diameter-instance"), arg),
                    str("draining"),
                    a(str("draining-response-timeout"), arg),
                    str("force-continue"),
                    b(str("ggsn-address"),
                      ipaddr
                    ),
                    a(str("ggsn-mcc-mnc"), arg),
                    a(str("final-response-timeout"), arg),
                    a(str("max-outstanding-requests"), arg),
                    str("send-origin-state-id"),
                    b(str("sftp-backup"),
                        c(
                            b(str("address"),
                              ipaddr
                            ),
                            a(str("accumulation-count"), arg),
                            a(str("accumulation-size"), arg),
                            a(str("accumulation-timeout"), arg),
                            a(str("directory"), arg),
                            a(str("file-name-prefix"), arg),
                            c(
                              b(str("logical-system"),
                                  sc(
                                      arg,
                                      a(str("routing-instance"), arg)
                                  )
                              ).as(:oneline),
                              a(str("routing-instance"), arg)
                            ),
                            b(str("node-ipv4-address"),
                              ipv4addr
                            ),
                            b(str("node-ipv6-address"),
                              ipv6addr
                            ),
                            a(str("port"), arg),
                            a(str("response-timeout"), arg),
                            a(str("retry-interval"), arg),
                            a(str("ssh-connection-linger"), quote | arg),
                            a(str("ssh-login"), quote | arg),
                            a(str("ssh-passphrase"), quote | arg),
                            str("ssh-log-verbose")
                        )
                    ),
                    b(str("user-name-include"),
                        c(
                            a(str("delimiter"), arg),
                            a(str("domain-name"), arg),
                            str("interface-name"),
                            str("base-interface-name"),
                            str("mac-address"),
                            str("nas-port-id"),
                            str("origin-host"),
                            str("origin-realm"),
                            a(str("user-prefix"), arg),
                            str("user-name")
                        )
                    )
                )
            ),
            b(str("global"),
                c(
                    a(str("service-context-id"), arg)
                )
            )
        )
    end

    rule(:odu_attributes) do
        c(
            b(str("rate"),
              (str("odu4"))
            ),
            str("is-ma"),
            str("no-is-ma"),
            b(str("tti"),
              otn_tti_attributes
            ),
            b(str("degrade"),
              otn_degrade
            ),
            a(str("exp-payload-type"), arg),
            b(str("prbs"),
              prbs_config
            )
        )
    end

    rule(:otn_degrade) do
        c(
            a(str("degm"), arg),
            a(str("degthr"), arg)
        )
    end

    rule(:otn_tti_attributes) do
        c(
            a(str("sapi"), arg),
            a(str("dapi"), arg),
            a(str("operator"), arg),
            a(str("exp-sapi"), arg),
            a(str("exp-dapi"), arg),
            b(str("tim-detect-mode"),
              (str("disabled") | str("sapi-only") | str("dapi-only") | str("sapi-and-dapi"))
            ),
            str("tim-act-enable"),
            str("no-tim-act-enable")
        )
    end

    rule(:otn_options_type) do
        c(
            str("laser-enable"),
            str("no-laser-enable"),
            str("is-ma"),
            str("no-is-ma"),
            str("line-loopback"),
            str("no-line-loopback"),
            str("local-loopback"),
            str("no-local-loopback"),
            str("prbs"),
            str("no-prbs"),
            str("odu-ttim-action-enable"),
            str("no-odu-ttim-action-enable"),
            str("otu-ttim-action-enable"),
            str("no-otu-ttim-action-enable"),
            str("transport-monitoring"),
            str("no-transport-monitoring"),
            b(str("odu-delay-management"),
                c(
                    str("monitor-end-point"),
                    str("no-monitor-end-point"),
                    str("start-measurement"),
                    str("no-start-measurement"),
                    str("bypass"),
                    str("no-bypass"),
                    a(str("number-of-frames"), arg),
                    str("remote-loop-enable"),
                    str("no-remote-loop-enable")
                )
            ),
            b(str("signal-degrade"),
                c(
                    a(str("interval"), arg),
                    a(str("ber-threshold-clear"), arg),
                    a(str("ber-threshold-signal-degrade"), arg),
                    a(str("q-threshold-signal-degrade-clear"), arg),
                    a(str("q-threshold-signal-degrade"), arg)
                )
            ),
            b(str("odu-signal-degrade"),
                c(
                    a(str("interval"), arg),
                    a(str("ber-threshold-clear"), arg),
                    a(str("ber-threshold-signal-degrade"), arg)
                )
            ),
            b(str("preemptive-fast-reroute"),
                c(
                    str("odu-signal-degrade-monitor-enable"),
                    str("no-odu-signal-degrade-monitor-enable"),
                    str("odu-backward-frr-enable"),
                    str("no-odu-backward-frr-enable"),
                    str("signal-degrade-monitor-enable"),
                    str("no-signal-degrade-monitor-enable"),
                    str("backward-frr-enable"),
                    str("no-backward-frr-enable")
                )
            ),
            b(str("fec"),
              (str("none") | str("gfec") | str("efec") | str("gfec-sdfec") | str("ufec") | str("sdfec") | str("hgfec") | str("sdfec15"))
            ),
            str("insert-odu-oci"),
            str("no-insert-odu-oci"),
            str("insert-odu-lck"),
            str("no-insert-odu-lck"),
            b(str("rate"),
              (str("pass-thru") | str("fixed-stuff-bytes") | str("no-fixed-stuff-bytes") | str("oc192") | str("otu3") | str("otu4"))
            ),
            b(str("bytes"),
                c(
                    a(str("transmit-payload-type"), arg)
                )
            ),
            b(str("tti"),
                c(
                    a(str("otu-dapi"), arg),
                    a(str("otu-sapi"), arg),
                    a(str("otu-expected-receive-dapi"), arg),
                    a(str("otu-expected-receive-sapi"), arg),
                    a(str("odu-dapi"), arg),
                    a(str("odu-sapi"), arg),
                    a(str("odu-expected-receive-dapi"), arg),
                    a(str("odu-expected-receive-sapi"), arg),
                    str("otu-dapi-first-byte-nul"),
                    str("no-otu-dapi-first-byte-nul"),
                    str("otu-sapi-first-byte-nul"),
                    str("no-otu-sapi-first-byte-nul"),
                    str("otu-expected-receive-dapi-first-byte-nul"),
                    str("no-otu-expected-receive-dapi-first-byte-nul"),
                    str("otu-expected-receive-sapi-first-byte-nul"),
                    str("no-otu-expected-receive-sapi-first-byte-nul"),
                    str("odu-dapi-first-byte-nul"),
                    str("no-odu-dapi-first-byte-nul"),
                    str("odu-sapi-first-byte-nul"),
                    str("no-odu-sapi-first-byte-nul"),
                    str("odu-expected-receive-dapi-first-byte-nul"),
                    str("no-odu-expected-receive-dapi-first-byte-nul"),
                    str("odu-expected-receive-sapi-first-byte-nul"),
                    str("no-odu-expected-receive-sapi-first-byte-nul")
                )
            ),
            b(str("trigger"),
                c(
                    b(str("oc-los"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oc-lof"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oc-lom"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oc-wavelength-lock"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oc-tsf"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-ais"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-bdi"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-iae"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-ttim"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-sd"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-fec-deg"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-fec-exe"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-ais"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-bdi"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-iae"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-bei"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-oci"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-lck"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-ttim"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-sd"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("opu-ptim"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("tca"),
                c(
                    b(str("otu-tca-es"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("otu-tca-ses"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("otu-tca-uas"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("otu-tca-bbe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("otu-tca-es-fe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("otu-tca-ses-fe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("otu-tca-uas-fe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("otu-tca-bbe-fe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("odu-tca-es"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("odu-tca-ses"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("odu-tca-uas"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("odu-tca-bbe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("odu-tca-es-fe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("odu-tca-ses-fe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("odu-tca-uas-fe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("odu-tca-bbe-fe"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline),
                    b(str("otu-tca-fec-ber"),
                        sc(
                            str("enable-tca"),
                            str("no-enable-tca"),
                            a(str("threshold"), arg),
                            a(str("threshold-24hrs"), arg)
                        )
                    ).as(:oneline)
                )
            )
        )
    end

    rule(:otu_attributes) do
        c(
            b(str("rate"),
              (str("otu4"))
            ),
            str("is-ma"),
            str("no-is-ma"),
            b(str("fec"),
              (str("none") | str("gfec") | str("hgfec"))
            ),
            b(str("loopback"),
              (str("none") | str("local") | str("line"))
            ),
            b(str("tti"),
              otn_tti_attributes
            ),
            b(str("degrade"),
              otn_degrade
            )
        )
    end

    rule(:output_plugin) do
      b(arg.as(:arg),
        c(
            b(str("parameters"),
              parameter_pair
            )
        )
      )
    end

    rule(:override_local_server_type) do
        c(
            a(str("interface-client-limit"), arg),
            str("no-arp"),
            str("bootp-support"),
            b(str("client-discover-match"),
                sc(
                    c(
                      str("option60-and-option82"),
                      str("incoming-interface")
                    )
                )
            ).as(:oneline),
            b(str("delay-offer"),
              dhcpv4_filter_option
            ),
            b(str("process-inform"),
                c(
                    a(str("pool"), arg)
                )
            ),
            b(str("include-option-82"),
                c(
                    str("nak"),
                    str("forcerenew")
                )
            ),
            str("delete-binding-on-renegotiation"),
            str("allow-no-end-option"),
            a(str("asymmetric-lease-time"), arg),
            a(str("protocol-attributes"), arg),
            a(str("dual-stack"), arg)
        )
    end

    rule(:dhcpv4_filter_option) do
        c(
            a(str("delay-time"), arg),
            b(str("based-on"),
                c(
                    b(str("option-82"),
                        c(
                            b(str("equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("not-equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_v6_option_ascii_hex
                            )
                        )
                    ),
                    b(str("option-60"),
                        c(
                            b(str("equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("not-equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_v6_option_ascii_hex
                            )
                        )
                    ),
                    b(str("option-77"),
                        c(
                            b(str("equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("not-equals"),
                              server_v6_option_ascii_hex
                            ),
                            b(str("starts-with"),
                              server_v6_option_ascii_hex
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:override_type) do
        c(
            str("no-unicast-replies"),
            str("allow-snooped-clients"),
            str("no-allow-snooped-clients"),
            str("allow-no-end-option"),
            str("always-write-giaddr"),
            b(str("always-write-option-82"),
              write_option_82_type
            ),
            a(str("user-defined-option-82"), arg),
            str("layer2-unicast-replies"),
            str("trust-option-82"),
            str("delay-authentication"),
            str("disable-relay"),
            str("no-bind-on-request"),
            a(str("interface-client-limit"), arg),
            str("no-arp"),
            str("bootp-support"),
            a(str("dual-stack"), arg),
            b(str("client-discover-match"),
                sc(
                    c(
                      str("option60-and-option82"),
                      str("incoming-interface")
                    )
                )
            ).as(:oneline),
            str("proxy-mode").as(:oneline),
            a(str("asymmetric-lease-time"), arg),
            b(str("replace-ip-source-with"),
                sc(
                    c(
                      str("giaddr")
                    )
                )
            ).as(:oneline),
            str("send-release-on-delete"),
            str("apply-secondary-as-giaddr"),
            b(str("relay-source"),
              interface_name
            ),
            str("delete-binding-on-renegotiation")
        )
    end

    rule(:p2mp_ldp_lsp_nh_obj) do
        c(
            b(a(str("root-address"), arg),
                c(
                    a(str("lsp-id"), arg),
                    b(a(str("group-address"), arg),
                        c(
                            a(str("source-address"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:packet_accounting_output_type) do
        c(
            a(str("aggregate-export-interval"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-active-timeout"), arg),
            b(str("cflowd"),
              cflowd_packet_accounting_type
            ),
            b(str("interface"),
              packet_export_intf_type
            )
        )
    end

    rule(:cflowd_packet_accounting_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("version"),
              (str("5") | str("8"))
            ),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            )
        )
      )
    end

    rule(:packet_export_intf_type) do
      b(arg.as(:arg),
        c(
            a(str("engine-id"), arg),
            a(str("engine-type"), arg),
            b(str("source-address"),
              ipaddr
            ),
            b(str("export-port"),
              export_port_address_type
            )
        )
      )
    end

    rule(:export_port_address_type) do
        c(
            b(str("address"),
              ipv4prefix
            ),
            b(str("gateway"),
              ipv4addr
            )
        )
    end

    rule(:parameter_pair) do
      b(arg.as(:arg),
        c(
            arg
        )
      )
    end

    rule(:pccd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("pccd-main") | str("pccd-config") | str("pccd-core") | str("pccd-ui") | str("pccd-rpd") | str("pccd-functions") | str("all"))).as(:oneline)
        )
    end

    rule(:pcp_rule_object) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("input") | str("output"))
            ),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      sfw_match_object
                    ),
                    b(str("then"),
                        c(
                            a(str("pcp-server"), arg)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:pcp_server_object) do
      b(arg.as(:arg),
        c(
            b(str("ipv4-address"),
              ipv4addr
            ),
            b(str("ipv6-address"),
              ipv6addr
            ),
            a(str("softwire-concentrator"), arg),
            a(str("mapping-lifetime-minimum"), arg),
            a(str("mapping-lifetime-maximum"), arg),
            a(str("short-lifetime-error"), arg),
            a(str("long-lifetime-error"), arg),
            a(str("max-mappings-per-client"), arg),
            b(str("pcp-options"),
                sc(
                    str("third-party"),
                    str("prefer-failure")
                )
            ).as(:oneline),
            b(str("nat-options"),
                c(
                    a(str("pool"), arg)
                )
            )
        )
      )
    end

    rule(:pcrf_definition) do
        c(
            b(a(str("partition"), arg),
                c(
                    str("accept-sdr"),
                    a(str("destination-realm"), arg),
                    a(str("destination-host"), arg),
                    a(str("diameter-instance"), arg),
                    str("draining"),
                    a(str("draining-response-timeout"), arg),
                    a(str("ip-can-type"), arg),
                    b(str("local-decision"),
                        c(
                            c(
                              str("grant"),
                              str("deny")
                            ),
                            a(str("reinit-timeout"), arg),
                            a(str("timeout"), arg)
                        )
                    ),
                    a(str("logout-response-timeout"), arg),
                    a(str("max-outstanding-requests"), arg),
                    str("report-local-rule"),
                    str("report-resource-allocation"),
                    str("report-successful-resource-allocation"),
                    str("send-dyn-subscription-indicator"),
                    str("send-network-family-indicator"),
                    str("send-origin-state-id"),
                    a(str("subscription-id-type"), arg),
                    b(str("subscription-id-data-include"),
                        c(
                            a(str("delimiter"), arg),
                            a(str("domain-name"), arg),
                            str("interface-name"),
                            str("vlan-tags"),
                            str("base-interface-name"),
                            str("mac-address"),
                            str("nas-port-id"),
                            str("origin-host"),
                            str("origin-realm"),
                            a(str("user-prefix"), arg),
                            str("user-name")
                        )
                    ),
                    a(str("update-response-timeout"), arg)
                )
            ),
            b(str("global"),
                c(
                    b(a(str("rule-param"), arg),
                        c(
                            a(str("param-name"), arg),
                            a(str("log-name"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:peer_group) do
      b(arg.as(:arg),
        c(
            b(str("local-ip-addr"),
              ipv4addr
            ),
            a(str("session-establishment-hold-time"), arg),
            a(str("redundancy-group-id-list"), arg),
            b(str("backup-liveness-detection"),
                c(
                    b(str("backup-peer-ip"),
                      ipv4addr
                    )
                )
            ),
            b(str("liveness-detection"),
                c(
                    b(str("version"),
                      (str("0") | str("1") | str("automatic"))
                    ),
                    a(str("minimum-interval"), arg),
                    a(str("minimum-transmit-interval"), arg),
                    a(str("minimum-receive-interval"), arg),
                    a(str("multiplier"), arg),
                    c(
                      str("no-adaptation")
                    ),
                    b(str("transmit-interval"),
                        c(
                            a(str("minimum-interval"), arg),
                            a(str("threshold"), arg)
                        )
                    ),
                    b(str("detection-time"),
                        c(
                            a(str("threshold"), arg)
                        )
                    )
                )
            ),
            a(str("authentication-key"), arg)
        )
      )
    end

    rule(:peers_type) do
      b(arg.as(:arg),
        c(
            a(str("user"), arg),
            b(str("authentication"),
              unreadable
            )
        )
      )
    end

    rule(:periodic_oam) do
        c(
            a(str("lsp-ping-interval"), arg),
            a(str("lsp-ping-multiplier"), arg),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("configuration") | str("pipe") | str("rpc-packet-details") | str("database") | str("network") | str("traceroute") | str("all"))).as(:oneline)
                )
            ),
            b(str("mpls-tp-mode"),
                c(
                    b(str("lsping-channel-type"),
                        c(
                            c(
                              str("ipv4"),
                              str("on-demand-cv")
                            )
                        )
                    )
                )
            ),
            b(str("bfd-port"),
                c(
                    b(str("import"),
                      policy_algebra
                    )
                )
            ),
            b(str("bfd-liveness-detection"),
                c(
                    b(str("version"),
                      (str("0") | str("1") | str("automatic"))
                    ),
                    a(str("minimum-interval"), arg),
                    a(str("minimum-transmit-interval"), arg),
                    a(str("minimum-receive-interval"), arg),
                    a(str("multiplier"), arg),
                    c(
                      str("no-adaptation")
                    ),
                    b(str("transmit-interval"),
                        c(
                            a(str("minimum-interval"), arg),
                            a(str("threshold"), arg)
                        )
                    ),
                    b(str("detection-time"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ),
                    b(str("failure-action"),
                        sc(
                            c(
                              str("teardown"),
                              b(str("make-before-break"),
                                  c(
                                      a(str("teardown-timeout"), arg)
                                  )
                              )
                            )
                        )
                    ).as(:oneline),
                    str("no-router-alert-option"),
                    str("use-ip-ttl-1")
                )
            ),
            b(str("performance-monitoring"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                                sc(
                                      arg,
                                    str("replace"),
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("no-stamp"),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("init") | str("error") | str("event") | str("general") | str("packet") | str("timer") | str("all"))).as(:oneline)
                        )
                    ),
                    b(str("querier"),
                        c(
                            b(str("loss"),
                                c(
                                    a(str("traffic-class"), enum(str("tc-0") | str("tc-1") | str("tc-2") | str("tc-3") | str("tc-4") | str("tc-5") | str("tc-6") | str("tc-7") | str("all") | str("none")),
                                        c(
                                            a(str("query-interval"), arg),
                                            b(str("measurement-quantity"),
                                              (str("bytes") | str("packets"))
                                            ),
                                            a(str("average-sample-size"), arg),
                                            a(str("loss-threshold"), arg),
                                            a(str("loss-threshold-window"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("delay"),
                                c(
                                    a(str("traffic-class"), enum(str("tc-0") | str("tc-1") | str("tc-2") | str("tc-3") | str("tc-4") | str("tc-5") | str("tc-6") | str("tc-7") | str("all")),
                                        c(
                                            a(str("query-interval"), arg),
                                            a(str("padding-size"), arg),
                                            a(str("average-sample-size"), arg),
                                            a(str("twcd-delay-threshold"), arg),
                                            a(str("rtt-delay-threshold"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("loss-delay"),
                                c(
                                    a(str("traffic-class"), enum(str("tc-0") | str("tc-1") | str("tc-2") | str("tc-3") | str("tc-4") | str("tc-5") | str("tc-6") | str("tc-7") | str("all") | str("none")),
                                        c(
                                            a(str("query-interval"), arg),
                                            b(str("measurement-quantity"),
                                              (str("bytes") | str("packets"))
                                            ),
                                            a(str("padding-size"), arg),
                                            a(str("average-sample-size"), arg),
                                            a(str("loss-threshold"), arg),
                                            a(str("loss-threshold-window"), arg),
                                            a(str("twcd-delay-threshold"), arg),
                                            a(str("rtt-delay-threshold"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("responder"),
                        c(
                            b(str("loss"),
                                c(
                                    a(str("min-query-interval"), arg)
                                )
                            ),
                            b(str("delay"),
                                c(
                                    a(str("min-query-interval"), arg)
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:pf_mapping) do
      b(arg.as(:arg),
        c(
            b(str("destined-port"),
                s(
                        arg,
                  a(str("translated-port"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:pgcp_gateway_object) do
      b(arg.as(:arg),
        c(
            b(str("gateway-address"),
              ipv4addr
            ),
            b(str("routing-instance"),
              (str("inet.0") | arg)
            ),
            a(str("gateway-port"), arg),
            a(str("cleanup-timeout"), arg),
            b(str("service-state"),
              (str("in-service") | str("out-of-service-forced") | str("out-of-service-graceful"))
            ),
            b(str("h248-timers"),
              pgcp_h248_timers_object
            ),
            b(str("h248-properties"),
              pgcp_h248_properties_object
            ),
            b(str("h248-options"),
              pgcp_h248_options_object
            ),
            a(str("max-concurrent-calls"), arg),
            b(str("gateway-controller"),
              pgcp_controller_object
            ),
            b(str("monitor"),
                c(
                    b(str("media"),
                        c(
                            str("rtp"),
                            str("rtcp")
                        )
                    )
                )
            ),
            b(str("graceful-restart"),
                c(
                    a(str("maximum-synchronization-time"), arg),
                    a(str("maximum-synchronization-mismatches"), arg),
                    str("no-synchronization"),
                    a(str("catchup-replication-delay"), arg)
                )
            ),
            b(str("fast-update-filters"),
                c(
                    a(str("maximum-terms"), arg),
                    a(str("maximum-term-percentage"), arg)
                )
            ),
            b(str("session-mirroring"),
              pgcp_gateway_session_mirroring_object
            ),
            b(str("data-inactivity-detection"),
                c(
                    a(str("inactivity-delay"), arg),
                    a(str("latch-deadlock-delay"), arg),
                    str("send-notification-on-delay"),
                    a(str("inactivity-duration"), arg),
                    str("stop-detection-on-drop"),
                    str("no-rtcp-check"),
                    b(str("report-service-change"),
                        c(
                            b(str("service-change-type"),
                              (str("forced-910") | str("forced-906"))
                            )
                        )
                    )
                )
            ),
            b(str("overload-control"),
                c(
                    a(str("queue-limit-percentage"), arg),
                    a(str("reject-new-calls-threshold"), arg),
                    a(str("reject-all-commands-threshold"), arg),
                    a(str("queue-maximum-length"), arg),
                    a(str("error-code"), arg)
                )
            ),
            b(str("platform"),
                c(
                    c(
                      str("routing-engine"),
                      b(str("device"),
                        interface_device
                      )
                    )
                )
            ),
            a(str("ipsec-transport-security-association"), arg)
        )
      )
    end

    rule(:pgcp_controller_object) do
      b(arg.as(:arg),
        c(
            b(str("controller-address"),
              ipv4addr
            ),
            a(str("controller-port"), arg),
            b(str("interim-ah-scheme"),
              pgcp_interim_ah_scheme_object
            ),
            c(
              str("remote-controller"),
              a(str("local-controller"), arg)
            )
        )
      )
    end

    rule(:pgcp_gateway_session_mirroring_object) do
        c(
            a(str("delivery-function"), arg),
            str("disable-session-mirroring")
        )
    end

    rule(:pgcp_h248_options_object) do
        c(
            b(str("service-change"),
              pgcp_h248_service_change_object
            ),
            str("audit-observed-events-returns"),
            b(str("encoding"),
                c(
                    str("no-octet-string-bit-mirroring"),
                    str("no-dscp-bit-mirroring"),
                    str("use-lower-case")
                )
            ),
            b(str("h248-profile"),
                c(
                    a(str("profile-name"), arg),
                    a(str("profile-version"), arg)
                )
            ),
            str("accept-emergency-calls-while-graceful"),
            str("implicit-tcp-latch"),
            str("implicit-tcp-source-filter")
        )
    end

    rule(:pgcp_h248_service_change_object) do
        c(
            b(str("control-association-indications"),
              control_association_indications_object
            ),
            b(str("virtual-interface-indications"),
              virtual_interface_indications_object
            ),
            b(str("context-indications"),
              context_indications_object
            ),
            str("use-wildcard-response")
        )
    end

    rule(:context_indications_object) do
        c(
            b(str("state-loss"),
              (str("forced-915") | str("forced-910") | str("none"))
            )
        )
    end

    rule(:control_association_indications_object) do
        c(
            b(str("up"),
              pgcp_association_up_object
            ),
            b(str("down"),
              pgcp_association_down_object
            ),
            b(str("disconnect"),
              pgcp_association_disconnect_object
            )
        )
    end

    rule(:pgcp_association_disconnect_object) do
        c(
            b(str("reconnect"),
              (str("disconnected-900") | str("restart-902"))
            ),
            b(str("controller-failure"),
              (str("restart-902") | str("failover-909"))
            )
        )
    end

    rule(:pgcp_association_down_object) do
        c(
            b(str("administrative"),
              (str("forced-905") | str("forced-908") | str("none"))
            ),
            b(str("failure"),
              (str("forced-904") | str("forced-908") | str("none"))
            ),
            b(str("graceful"),
              (str("none") | str("graceful-905"))
            )
        )
    end

    rule(:pgcp_association_up_object) do
        c(
            b(str("failover-cold"),
              (str("restart-901") | str("failover-920"))
            ),
            b(str("failover-warm"),
              (str("restart-902") | str("failover-919"))
            ),
            b(str("cancel-graceful"),
              (str("none") | str("restart-918"))
            )
        )
    end

    rule(:pgcp_h248_properties_object) do
        c(
            b(str("base-root"),
              pgcp_h248_base_root_object
            ),
            b(str("segmentation"),
              pgcp_h248_segmentation_object
            ),
            b(str("diffserv"),
              pgcp_h248_diffserv_object
            ),
            b(str("hanging-termination-detection"),
              pgcp_h248_hangterm_object
            ),
            b(str("traffic-management"),
              pgcp_h248_traffic_management_object
            ),
            b(str("notification-behavior"),
              pgcp_h248_notification_behavior_object
            ),
            b(str("application-data-inactivity-detection"),
              pgcp_h248_application_data_inactivity_detection_object
            ),
            b(str("event-timestamp-notification"),
              pgcp_h248_event_timestamp_notification_object
            ),
            b(str("inactivity-timer"),
              pgcp_h248_inactivity_timer_object
            )
        )
    end

    rule(:pgcp_h248_application_data_inactivity_detection_object) do
        c(
            b(str("ip-flow-stop-detection"),
              (str("immediate-notify") | str("regulated-notify"))
            )
        )
    end

    rule(:pgcp_h248_event_timestamp_notification_object) do
        c(
            b(str("request-timestamp"),
              (str("requested") | str("suppressed") | str("autonomous"))
            )
        )
    end

    rule(:pgcp_h248_hangterm_object) do
        c(
            a(str("timerx"), arg)
        )
    end

    rule(:pgcp_h248_inactivity_timer_object) do
        c(
            b(str("inactivity-timeout"),
                c(
                    str("detect"),
                    b(str("maximum-inactivity-time"),
                        c(
                            a(str("default"), arg),
                            a(str("minimum"), arg),
                            a(str("maximum"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:pgcp_h248_notification_behavior_object) do
        c(
            b(str("notification-regulation"),
                c(
                    a(str("default"), arg)
                )
            )
        )
    end

    rule(:pgcp_h248_base_root_object) do
        c(
            b(str("normal-mg-execution-time"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(str("mg-provisional-response-timer-value"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(str("mg-originated-pending-limit"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(str("normal-mgc-execution-time"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(str("mgc-provisional-response-timer-value"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(str("mgc-originated-pending-limit"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            )
        )
    end

    rule(:pgcp_h248_diffserv_object) do
        c(
            b(str("dscp"),
                c(
                    b(str("default"),
                      (str("do-not-change") | str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("nc1") | str("nc2") | str("be") | arg)
                    ),
                    str("ignore-signaled-value")
                )
            )
        )
    end

    rule(:pgcp_h248_segmentation_object) do
        c(
            b(str("mgc-segmentation-timer"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(str("mgc-maximum-pdu-size"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(str("mg-segmentation-timer"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            ),
            b(str("mg-maximum-pdu-size"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    a(str("maximum"), arg)
                )
            )
        )
    end

    rule(:pgcp_h248_timers_object) do
        c(
            a(str("maximum-waiting-delay"), arg),
            a(str("tmax-retransmission-delay"), arg),
            a(str("initial-average-ack-delay"), arg),
            a(str("maximum-net-propagation-delay"), arg)
        )
    end

    rule(:pgcp_h248_traffic_management_object) do
        c(
            b(str("sustained-data-rate"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    b(str("maximum"),
                          enum(arg)
                    ),
                    b(str("rtcp"),
                      pgcp_h248_rtcp_rate_units_object
                    ),
                    str("rtcp-include")
                )
            ),
            b(str("peak-data-rate"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    b(str("maximum"),
                          enum(arg)
                    ),
                    b(str("rtcp"),
                      pgcp_h248_rtcp_rate_units_object
                    )
                )
            ),
            b(str("max-burst-size"),
                c(
                    a(str("default"), arg),
                    a(str("minimum"), arg),
                    b(str("maximum"),
                          enum(arg)
                    ),
                    b(str("rtcp"),
                      pgcp_h248_rtcp_burst_units_object
                    )
                )
            )
        )
    end

    rule(:pgcp_h248_rtcp_burst_units_object) do
        c(
            c(
              a(str("percentage"), arg),
              a(str("fixed-value"), arg)
            )
        )
    end

    rule(:pgcp_h248_rtcp_rate_units_object) do
        c(
            c(
              a(str("percentage"), arg),
              a(str("fixed-value"), arg)
            )
        )
    end

    rule(:pgcp_interim_ah_scheme_object) do
        c(
            b(str("algorithm"),
              (str("hmac-null"))
            )
        )
    end

    rule(:pgcp_media_service_object) do
      b(arg.as(:arg),
        c(
            a(str("nat-pool"), arg)
        )
      )
    end

    rule(:pgcp_rule_object) do
      b(arg.as(:arg),
        c(
            a(str("gateway"), arg),
            c(
              a(str("media-service"), arg),
              a(str("nat-pool"), arg)
            )
        )
      )
    end

    rule(:pgcp_session_mirroring_object) do
        c(
            b(str("delivery-function"),
              pgcp_delivery_function_object
            ),
            str("disable-session-mirroring")
        )
    end

    rule(:pgcp_delivery_function_object) do
      b(arg.as(:arg),
        c(
            b(str("destination-address"),
              ipv4addr
            ),
            a(str("destination-port"), arg),
            a(str("network-operator-id"), arg),
            b(str("source-address"),
              ipv4addr
            ),
            a(str("source-port"), arg),
            b(str("memory-managment"),
              pgcp_debug_mem_mgmt_object
            )
        )
      )
    end

    rule(:pgcp_debug_mem_mgmt_object) do
        c(
            b(str("operational-mode"),
              (str("fast") | str("type-tracking") | str("location-tracking"))
            )
        )
    end

    rule(:pgcp_virtual_interface_object) do
      b(arg.as(:arg),
        c(
            b(str("routing-instance"),
              (str("inet.0") | arg)
            ),
            b(str("service-state"),
              (str("in-service") | str("out-of-service-forced") | str("out-of-service-graceful"))
            ),
            c(
              a(str("media-service"), arg),
              a(str("nat-pool"), arg)
            ),
            b(str("interface"),
              interface_name
            )
        )
      )
    end

    rule(:pim_bootstrap_options_type) do
        c(
            a(str("priority"), arg),
            b(str("import"),
              policy_algebra
            ),
            b(str("export"),
              policy_algebra
            )
        )
    end

    rule(:pim_filter_obj) do
        c(
            b(str("match-on"),
              (str("prefix"))
            ),
            b(str("policy"),
              policy_algebra
            )
        ).as(:oneline)
    end

    rule(:pim_rp_group_range_type) do
      b(arg.as(:arg),
        c(
            a(str("nexthop-hold-time"), arg)
        )
      )
    end

    rule(:pm_rspan_bridge_domain) do
      arg.as(:arg)
    end

    rule(:pm_rspan_vlan) do
      b(arg.as(:arg),
        c(
            str("no-tag")
        )
      )
    end

    rule(:pm_family_input_type) do
        c(
            a(str("rate"), arg),
            a(str("run-length"), arg),
            a(str("maximum-packet-length"), arg)
        )
    end

    rule(:pmond_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("events") | str("heartbeat") | str("process-tracking") | str("ui") | str("all"))).as(:oneline)
        )
    end

    rule(:port_range) do
      b(arg.as(:arg),
        c(
            a(str("maximum-port"), arg)
        )
      ).as(:oneline)
    end

    rule(:ppp_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("access") | str("address-pool") | str("auth") | str("chap") | str("pap") | str("config") | str("ifdb") | str("lcp") | str("memory") | str("message") | str("mlppp") | str("ncp") | str("ppp") | str("radius") | str("redundancy") | str("rtsock") | str("session") | str("signal") | str("timer") | str("ui") | str("ci") | str("all"))).as(:oneline)
        )
    end

    rule(:ppp_options_type) do
        c(
            a(str("dynamic-profile"), arg),
            b(str("chap"),
                c(
                    c(
                      a(str("access-profile"), arg),
                      b(str("default-chap-secret"),
                        unreadable
                      )
                    ),
                    a(str("local-name"), arg),
                    str("no-rfc2486"),
                    str("passive"),
                    b(str("challenge-length"),
                        sc(
                            a(str("minimum"), arg),
                            a(str("maximum"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("pap"),
                c(
                    c(
                      a(str("access-profile"), arg),
                      b(str("default-password"),
                        unreadable
                      )
                    ),
                    a(str("local-name"), arg),
                    str("no-rfc2486"),
                    b(str("local-password"),
                      unreadable
                    ),
                    str("passive")
                )
            ),
            b(str("authentication"),
              (str("pap") | str("chap"))
            ),
            b(str("compression"),
                sc(
                    str("acfc"),
                    str("pfc")
                )
            ).as(:oneline),
            a(str("lcp-restart-timer"), arg),
            a(str("ncp-restart-timer"), arg),
            str("no-termination-request"),
            a(str("loopback-clear-timer"), arg),
            a(str("lcp-max-conf-req"), arg),
            a(str("ncp-max-conf-req"), arg),
            str("on-demand-ip-address"),
            a(str("aaa-options"), arg),
            b(str("initiate-ncp"),
                c(
                    str("ip"),
                    str("ipv6"),
                    str("dual-stack-passive")
                )
            ),
            a(str("mru"), arg),
            b(str("mtu"),
              (str("use-lower-layer") | arg)
            ),
            str("peer-ip-address-optional"),
            str("ipcp-suggest-dns-option"),
            str("ignore-magic-number-mismatch"),
            b(str("local-authentication"),
              local_auth_type
            ),
            str("lcp-connection-update")
        )
    end

    rule(:local_auth_type) do
        c(
            a(str("password"), arg),
            b(str("username-include"),
                c(
                    str("mac-address"),
                    str("circuit-id"),
                    str("remote-id"),
                    a(str("domain-name"), arg),
                    a(str("delimiter"), arg)
                )
            )
        )
    end

    rule(:pppoe_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("config") | str("events") | str("gres") | str("init") | str("interface-db") | str("memory") | str("protocol") | str("rtsock") | str("session-db") | str("signal") | str("state") | str("stats") | str("timer") | str("ui") | str("all"))).as(:oneline),
            b(str("filter"),
                c(
                    a(str("aci"), arg),
                    a(str("ari"), arg),
                    a(str("service-name"), arg),
                    b(str("underlying-interface"),
                      (arg | arg)
                    ),
                    b(str("user"),
                        c(
                              arg
                        )
                    )
                )
            )
        )
    end

    rule(:pppoe_options_type) do
        c(
            b(str("underlying-interface"),
              (arg | arg)
            ),
            a(str("idle-timeout"), arg),
            a(str("access-concentrator"), arg),
            a(str("service-name"), arg),
            a(str("auto-reconnect"), arg),
            c(
              str("server"),
              str("client")
            ),
            a(str("ppp-max-payload"), arg)
        )
    end

    rule(:pppoe_underlying_options_type) do
        c(
            a(str("access-concentrator"), arg),
            str("direct-connect"),
            str("duplicate-protection"),
            a(str("dynamic-profile"), arg),
            a(str("max-sessions"), arg),
            str("max-sessions-vsa-ignore"),
            a(str("service-name-table"), arg),
            b(str("short-cycle-protection"),
                c(
                    a(str("lockout-time-min"), arg),
                    a(str("lockout-time-max"), arg),
                    b(str("filter"),
                      (str("aci"))
                    )
                )
            )
        )
    end

    rule(:prbs_config) do
        c(
            str("enable-prbs"),
            str("no-enable-prbs"),
            b(str("direction"),
              (str("local") | str("line"))
            ),
            b(str("pattern"),
              (str("prbs-31") | str("prbs-23") | str("prbs-15") | str("prbs-7"))
            ),
            str("invert"),
            str("no-invert")
        )
    end

    rule(:prefix_action) do
      b(arg.as(:arg),
        c(
            a(str("policer"), arg),
            str("count"),
            str("filter-specific"),
            a(str("subnet-prefix-length"), arg),
            c(
              a(str("source-prefix-length"), arg),
              a(str("destination-prefix-length"), arg)
            )
        )
      )
    end

    rule(:prefix_list_items) do
      arg.as(:arg)
    end

    rule(:profile_radius_server_object) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("preauthentication-port"), arg),
            a(str("accounting-port"), arg),
            a(str("dynamic-request-port"), arg),
            b(str("secret"),
              unreadable
            ),
            b(str("preauthentication-secret"),
              unreadable
            ),
            a(str("timeout"), arg),
            a(str("retry"), arg),
            a(str("accounting-timeout"), arg),
            a(str("accounting-retry"), arg),
            a(str("max-outstanding-requests"), arg),
            b(str("source-address"),
              ipaddr
            ),
            a(str("routing-instance"), arg),
            a(str("radsec-destination"), arg)
        )
      )
    end

    rule(:programmable_rpd_type) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                        sc(
                              arg,
                            str("replace"),
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("no-stamp"),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("client") | str("japi") | str("routing-interface") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"))).as(:oneline)
                )
            ),
            b(str("purge-timeout"),
                sc(
                    c(
                      str("never"),
                        arg
                    )
                )
            ).as(:oneline),
            b(a(str("client"), arg),
                c(
                    a(str("interface-notification"), arg)
                )
            )
        )
    end

    rule(:proto_object) do
      b(arg.as(:arg),
        c(
            b(str("tunable-name"),
              tunable_object
            )
        )
      )
    end

    rule(:protocol_attribute_type) do
      b(arg.as(:arg),
        c(
            b(str("dhcp"),
              dhcp_attribute_type
            ),
            b(str("dhcpv6"),
              dhcp_attribute_type
            )
        )
      )
    end

    rule(:proxy_object) do
        c(
            a(str("server"), arg),
            a(str("port"), arg),
            a(str("username"), arg),
            b(str("password"),
              unreadable
            )
        )
    end

    rule(:qualified_nh_obj) do
      b(arg.as(:arg),
        c(
            a(str("preference"), arg),
            a(str("metric"), arg),
            b(str("interface"),
              interface_name
            ),
            b(str("mac-address"),
              mac_unicast
            ),
            a(str("tag"), arg),
            b(str("bfd-liveness-detection"),
                c(
                    b(str("version"),
                      (str("0") | str("1") | str("automatic"))
                    ),
                    a(str("minimum-interval"), arg),
                    a(str("minimum-transmit-interval"), arg),
                    a(str("minimum-receive-interval"), arg),
                    a(str("multiplier"), arg),
                    c(
                      str("no-adaptation")
                    ),
                    b(str("transmit-interval"),
                        c(
                            a(str("minimum-interval"), arg),
                            a(str("threshold"), arg)
                        )
                    ),
                    b(str("detection-time"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ),
                    b(str("authentication"),
                        c(
                            a(str("key-chain"), arg),
                            b(str("algorithm"),
                              (str("simple-password") | str("keyed-md5") | str("meticulous-keyed-md5") | str("keyed-sha-1") | str("meticulous-keyed-sha-1"))
                            ),
                            str("loose-check")
                        )
                    ),
                    b(str("neighbor"),
                      ipaddr
                    ),
                    b(str("local-address"),
                      ipaddr
                    ),
                    a(str("holddown-interval"), arg),
                    a(str("minimum-receive-ttl"), arg)
                )
            )
        )
      )
    end

    rule(:r2cp_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("configuration") | str("event") | str("interface") | str("node") | str("packet") | str("rtsock") | str("session") | str("socket") | str("timer") | str("virtual-channel") | str("all"))).as(:oneline)
        )
    end

    rule(:radius_disconnect_object) do
      b(arg.as(:arg),
        c(
            b(str("secret"),
              unreadable
            )
        )
      )
    end

    rule(:radius_server_object) do
      b(arg.as(:arg),
        c(
            a(str("routing-instance"), arg),
            a(str("port"), arg),
            a(str("preauthentication-port"), arg),
            a(str("accounting-port"), arg),
            a(str("dynamic-request-port"), arg),
            b(str("secret"),
              unreadable
            ),
            b(str("preauthentication-secret"),
              unreadable
            ),
            a(str("timeout"), arg),
            a(str("retry"), arg),
            a(str("accounting-timeout"), arg),
            a(str("accounting-retry"), arg),
            a(str("max-outstanding-requests"), arg),
            b(str("source-address"),
              ipaddr
            )
        )
      )
    end

    rule(:radius_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("send") | str("send-detail") | str("receive") | str("receive-detail") | str("timeout") | str("state") | str("all"))).as(:oneline),
            a(str("server"), arg),
            a(str("client"), arg),
            a(str("snoop-segment"), arg)
        )
    end

    rule(:radius_options_vlan_type) do
        c(
            b(a(str("nas-port-options"), arg),
                c(
                    b(str("nas-port-type"),
                      (str("async") | str("sync") | str("isdn-sync") | str("isdn-v120") | str("isdn-v110") | str("virtual") | str("piafs") | str("hdlc-clear-channel") | str("x25") | str("x75") | str("g3-fax") | str("sdsl") | str("adsl-cap") | str("adsl-dmt") | str("idsl") | str("ethernet") | str("xdsl") | str("cable") | str("wireless") | str("wireless-ieee80211") | str("token-ring") | str("fddi") | str("wireless-cdma2000") | str("wireless-umts") | str("wireless-1x-ev") | str("iapp") | arg)
                    ),
                    b(str("nas-port-extended-format"),
                        c(
                            a(str("ae-width"), arg),
                            a(str("slot"), arg),
                            a(str("slot-width"), arg),
                            a(str("adapter"), arg),
                            a(str("adapter-width"), arg),
                            a(str("port"), arg),
                            a(str("port-width"), arg),
                            a(str("pw-width"), arg),
                            a(str("stacked-vlan-width"), arg),
                            a(str("vlan-width"), arg),
                            str("stacked"),
                            a(str("vpi-width"), arg),
                            a(str("vci-width"), arg)
                        )
                    ),
                    a(str("stacked-vlan-ranges"), arg),
                    a(str("vlan-ranges"), arg)
                )
            )
        )
    end

    rule(:radsec_definition) do
        c(
            b(a(str("destination"), arg),
                c(
                    b(str("address"),
                      ipaddr
                    ),
                    b(str("dynamic-requests"),
                        c(
                            b(str("source-address"),
                              ipaddr
                            ),
                            a(str("source-port"), arg),
                            c(
                              b(str("logical-system"),
                                  sc(
                                      arg,
                                      a(str("routing-instance"), arg)
                                  )
                              ).as(:oneline),
                              a(str("routing-instance"), arg)
                            )
                        )
                    ),
                    a(str("id-reuse-timeout"), arg),
                    c(
                      b(str("logical-system"),
                          sc(
                              arg,
                              a(str("routing-instance"), arg)
                          )
                      ).as(:oneline),
                      a(str("routing-instance"), arg)
                    ),
                    a(str("max-tx-buffers"), arg),
                    a(str("port"), arg),
                    b(str("source-address"),
                      ipaddr
                    ),
                    a(str("tls-certificate"), arg),
                    b(str("tls-force-ciphers"),
                      (str("medium") | str("low"))
                    ),
                    b(str("tls-min-version"),
                      (str("v1.1") | str("v1.2"))
                    ),
                    a(str("tls-peer-name"), arg),
                    a(str("tls-timeout"), arg)
                )
            )
        )
    end

    rule(:reconfigure_trigger_type) do
        c(
            str("radius-disconnect")
        )
    end

    rule(:reconfigure_type) do
        c(
            str("clear-on-abort"),
            a(str("attempts"), arg),
            a(str("timeout"), arg),
            a(str("token"), arg),
            b(str("trigger"),
              reconfigure_trigger_type
            ),
            str("support-option-pd-exclude")
        )
    end

    rule(:redundancy_group_type) do
      b(arg.as(:arg),
        c(
            a(str("redundancy-group-id"), arg),
            b(str("protocol"),
                c(
                    b(str("evpn"),
                        c(
                            b(str("peer-ip"),
                              ipv4addr
                            ),
                            b(str("local-ip"),
                              ipv4addr
                            ),
                            a(str("routing-instance"), arg)
                        )
                    )
                )
            ),
            b(a(str("peer-chassis-id"), arg),
                c(
                    str("no-auto-vlan-provisioning"),
                    b(str("inter-chassis-link"),
                      interface_device
                    ),
                    str("no-auto-iccp-provisioning"),
                    a(str("session-establishment-hold-time"), arg),
                    b(str("liveness-detection"),
                        c(
                            b(str("version"),
                              (str("0") | str("1") | str("automatic"))
                            ),
                            a(str("minimum-interval"), arg),
                            a(str("minimum-transmit-interval"), arg),
                            a(str("minimum-receive-interval"), arg),
                            a(str("multiplier"), arg),
                            c(
                              str("no-adaptation")
                            ),
                            b(str("transmit-interval"),
                                c(
                                    a(str("minimum-interval"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            b(str("detection-time"),
                                c(
                                    a(str("threshold"), arg)
                                )
                            )
                        )
                    ),
                    a(str("authentication-key"), arg),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("flag"), enum(str("error") | str("event") | str("packet") | str("pipe") | str("pipe-detail") | str("all"))).as(:oneline)
                        )
                    )
                )
            ),
            a(str("satellite"), arg),
            b(str("system-mac-address"),
              mac_unicast
            ),
            a(str("cluster"), arg)
        )
      )
    end

    rule(:registration_policy_type) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      new_transaction_from_type
                    ),
                    b(str("then"),
                      new_registration_then_type
                    )
                )
            )
        )
      )
    end

    rule(:new_registration_then_type) do
        c(
            b(str("nat-traversal"),
              nat_traversal_action
            )
        )
    end

    rule(:nat_traversal_action) do
        c(
            b(str("nat-traversal-strategy"),
              (str("never") | str("always") | str("by-via"))
            ),
            a(str("keepalive-interval"), arg),
            a(str("minimum-registration-interval"), arg),
            b(str("keepalive-mechanisms"),
                c(
                    str("register-fast-expiration")
                )
            )
        )
    end

    rule(:new_transaction_from_type) do
        c(
            b(str("source-address"),
              ipaddr
            ),
            b(str("method"),
              transaction_method_type
            ),
            b(str("request-uri"),
                sc(
                    b(str("regular-expression"),
                      regular_expression
                    ),
                    b(str("registration-state"),
                      (str("registered") | str("not-registered"))
                    ),
                    b(str("uri-hiding"),
                      (str("hidden-uri") | str("not-hidden-uri"))
                    )
                )
            ).as(:oneline),
            b(str("contact"),
                sc(
                    b(str("regular-expression"),
                      regular_expression
                    ),
                    b(str("registration-state"),
                      (str("registered") | str("not-registered"))
                    ),
                    b(str("uri-hiding"),
                      (str("hidden-uri") | str("not-hidden-uri"))
                    )
                )
            ).as(:oneline)
        )
    end

    rule(:relay_active_leasequery_v4_type) do
        c(
            str("topology-discover"),
            a(str("peer-address"), arg),
            a(str("timeout"), arg),
            a(str("idle-timeout"), arg)
        )
    end

    rule(:relay_active_leasequery_v6_type) do
        c(
            str("topology-discover"),
            a(str("timeout"), arg),
            a(str("idle-timeout"), arg),
            a(str("peer-address"), arg)
        )
    end

    rule(:relay_bulk_leasequery_v4_type) do
        c(
            a(str("attempts"), arg),
            a(str("timeout"), arg)
        )
    end

    rule(:relay_bulk_leasequery_v6_type) do
        c(
            a(str("attempts"), arg),
            a(str("timeout"), arg),
            b(str("trigger"),
                sc(
                    str("automatic")
                )
            ).as(:oneline)
        )
    end

    rule(:relay_leasequery_type) do
        c(
            a(str("attempts"), arg),
            a(str("timeout"), arg)
        )
    end

    rule(:relay_option_60_type_group) do
        c(
            b(str("vendor-option"),
                c(
                    b(str("equals"),
                      relay_option_60_match_group
                    ),
                    b(str("not-equals"),
                      relay_option_60_match_group
                    ),
                    b(str("starts-with"),
                      relay_option_60_match_group
                    ),
                    c(
                      a(str("default-relay-server-group"), arg),
                      a(str("default-local-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            )
        )
    end

    rule(:relay_option_60_match_group) do
        c(
            b(a(str("ascii"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      a(str("local-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            ),
            b(a(str("hexadecimal"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      a(str("local-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            )
        )
    end

    rule(:relay_option_60_type_top) do
        c(
            b(str("vendor-option"),
                c(
                    b(str("equals"),
                      relay_option_60_match_top
                    ),
                    b(str("not-equals"),
                      relay_option_60_match_top
                    ),
                    b(str("starts-with"),
                      relay_option_60_match_top
                    ),
                    c(
                      a(str("default-relay-server-group"), arg),
                      a(str("default-local-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            )
        )
    end

    rule(:relay_option_60_match_top) do
        c(
            b(a(str("ascii"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      a(str("local-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            ),
            b(a(str("hexadecimal"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      a(str("local-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            )
        )
    end

    rule(:relay_option_82_type) do
        c(
            b(str("circuit-id"),
                c(
                    b(str("prefix"),
                        c(
                            str("host-name"),
                            str("logical-system-name"),
                            str("routing-instance-name")
                        )
                    ),
                    b(str("use-interface-description"),
                      (str("logical") | str("device"))
                    ),
                    str("use-vlan-id"),
                    str("vlan-id-only"),
                    str("no-vlan-interface-name"),
                    str("include-irb-and-l2"),
                    str("user-defined"),
                    str("keep-incoming-circuit-id")
                )
            ),
            b(str("remote-id"),
                c(
                    b(str("prefix"),
                        c(
                            str("host-name"),
                            str("logical-system-name"),
                            str("routing-instance-name")
                        )
                    ),
                    b(str("use-interface-description"),
                      (str("logical") | str("device"))
                    ),
                    str("use-vlan-id"),
                    str("no-vlan-interface-name"),
                    str("include-irb-and-l2"),
                    str("hostname-only"),
                    str("keep-incoming-remote-id"),
                    a(str("use-string"), arg)
                )
            ),
            str("server-id-override"),
            str("exclude-relay-agent-identifier"),
            b(str("vendor-specific"),
              jdhcp_vendor_specific_type
            ).as(:oneline)
        )
    end

    rule(:relay_v4_option_ascii_hex) do
        c(
            b(a(str("ascii"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      a(str("local-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            ),
            b(a(str("hexadecimal"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      a(str("local-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            )
        )
    end

    rule(:relay_v6_option_ascii_hex) do
        c(
            b(a(str("ascii"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            ),
            b(a(str("hexadecimal"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      str("drop"),
                      str("forward-only")
                    )
                )
            )
        )
    end

    rule(:res_cleanupd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("events") | str("gencfg") | str("module") | str("sysvsem") | str("sysvshm") | str("tracking") | str("ui") | str("all"))).as(:oneline)
        )
    end

    rule(:resource_monitor_type) do
        c(
            a(str("resource-category"), enum(str("jtree")),
                c(
                    a(str("resource-type"), enum(str("free-pages") | str("free-dwords") | str("contiguous-pages")),
                        c(
                            a(str("low-watermark"), arg),
                            a(str("high-watermark"), arg)
                        )
                    )
                )
            ),
            b(str("traceoptions"),
              resource_monitor_traceoptions_type
            ),
            str("no-throttle"),
            str("no-load-throttle"),
            str("no-logging"),
            a(str("high-threshold"), arg),
            a(str("high-cos-queue-threshold"), arg),
            a(str("free-heap-memory-watermark"), arg),
            a(str("free-nh-memory-watermark"), arg),
            a(str("free-fw-memory-watermark"), arg),
            b(str("subscribers-limit"),
                c(
                    a(str("client-type"), enum(str("pppoe") | str("dhcp") | str("l2tp") | str("any")),
                        c(
                            b(str("chassis"),
                                c(
                                    a(str("limit"), arg)
                                )
                            ),
                            b(str("fpc"),
                              rsmon_fpc_type
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:resource_monitor_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("all"))).as(:oneline)
        )
    end

    rule(:resources_type) do
        c(
            b(str("cpu"),
                c(
                    a(str("priority"), arg),
                    a(str("time"), arg)
                )
            ),
            b(str("memory"),
                c(
                    a(str("data-size"), arg),
                    a(str("locked-in"), arg),
                    a(str("resident-set-size"), arg),
                    a(str("socket-buffers"), arg),
                    a(str("stack-size"), arg)
                )
            ),
            b(str("file"),
                c(
                    a(str("size"), arg),
                    a(str("open"), arg),
                    a(str("core-size"), arg)
                )
            )
        )
    end

    rule(:rib_aggregate_type) do
        c(
            b(str("defaults"),
                c(
                    b(str("metric"),
                      rib_static_metric_type
                    ),
                    b(str("metric2"),
                      rib_static_metric_type
                    ),
                    b(str("metric3"),
                      rib_static_metric_type
                    ),
                    b(str("metric4"),
                      rib_static_metric_type
                    ),
                    b(str("tag"),
                      rib_static_metric_type
                    ),
                    b(str("tag2"),
                      rib_static_metric_type
                    ),
                    b(str("preference"),
                      rib_static_metric_type
                    ),
                    b(str("preference2"),
                      rib_static_metric_type
                    ),
                    b(str("color"),
                      rib_static_metric_type
                    ),
                    b(str("color2"),
                      rib_static_metric_type
                    ),
                    b(str("community"),
                      community
                    ),
                    b(str("as-path"),
                      c(
                        a(str("path"), quote | arg),
                            b(str("origin"),
                              (str("igp") | str("egp") | str("incomplete"))
                            ),
                            str("atomic-aggregate"),
                            b(str("aggregator"),
                                ca(
                                      ipv4addr
                                )
                            )
                        )
                    ),
                    str("discard"),
                    a(str("next-table"), arg),
                    c(
                      str("brief"),
                      str("full")
                    ),
                    c(
                      str("active"),
                      str("passive")
                    )
                )
            ),
            b(a(str("route"), arg),
                c(
                    b(str("policy"),
                      policy_algebra
                    ),
                    b(str("metric"),
                      rib_static_metric_type
                    ),
                    b(str("metric2"),
                      rib_static_metric_type
                    ),
                    b(str("metric3"),
                      rib_static_metric_type
                    ),
                    b(str("metric4"),
                      rib_static_metric_type
                    ),
                    b(str("tag"),
                      rib_static_metric_type
                    ),
                    b(str("tag2"),
                      rib_static_metric_type
                    ),
                    b(str("preference"),
                      rib_static_metric_type
                    ),
                    b(str("preference2"),
                      rib_static_metric_type
                    ),
                    b(str("color"),
                      rib_static_metric_type
                    ),
                    b(str("color2"),
                      rib_static_metric_type
                    ),
                    b(str("community"),
                      community
                    ),
                    b(str("as-path"),
                      c(
                        a(str("path"), quote | arg),
                            b(str("origin"),
                              (str("igp") | str("egp") | str("incomplete"))
                            ),
                            str("atomic-aggregate"),
                            b(str("aggregator"),
                                ca(
                                      ipv4addr
                                )
                            )
                        )
                    ),
                    str("discard"),
                    a(str("next-table"), arg),
                    c(
                      str("brief"),
                      str("full")
                    ),
                    c(
                      str("active"),
                      str("passive")
                    )
                )
            )
        )
    end

    rule(:rib_group_inet_type) do
      ca(
        a(arg, arg)
        ).as(:oneline)
    end

    rule(:rib_group_type) do
        ca(
            a(str("inet"), arg),
            a(str("inet3"), arg),
            a(str("inet6"), arg),
            a(str("inet63"), arg)
        )
    end

    rule(:rib_static_metric_type) do
        ca(
            a(str("type"), arg)
        ).as(:oneline)
    end

    rule(:rip_filter_obj) do
        c(
            b(str("match-on"),
              (str("prefix"))
            ),
            b(str("policy"),
              policy_algebra
            )
        ).as(:oneline)
    end

    rule(:rmopd_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("configuration") | str("ipc") | str("ppm") | str("rpd") | str("info") | str("statistics") | str("error") | str("all"))).as(:oneline)
        )
    end

    rule(:rmps_clnt_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("infra") | str("memory") | str("communication") | str("resource-tables") | str("info-tables") | str("redundancy") | str("all"))).as(:oneline)
        )
    end

    rule(:rmpsd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("config") | str("gres") | str("init") | str("memory") | str("communication") | str("license-management") | str("signal") | str("state") | str("timer") | str("ui") | str("resource-manager") | str("info-manager") | str("packet-steering") | str("all"))).as(:oneline)
        )
    end

    rule(:route_filter_list_items) do
        s(
                arg,
          c(
            str("exact"),
            str("longer"),
            str("orlonger"),
            a(str("upto"), arg),
            a(str("through"), arg),
            a(str("prefix-length-range"), arg),
            a(str("address-mask"), arg)
          ),
          c(
            b(str("label"),
                sc(
                    c(
                      b(str("range"),
                          sc(
                              c(
                                arg
                              )
                          )
                      ).as(:oneline),
                        arg
                    )
                )
            ).as(:oneline),
            str("get-route-range"),
            b(str("metric"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg),
                      b(str("igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("expression"),
                        metric_expression_type
                      ),
                      str("aigp"),
                      b(str("effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline)
                    )
                )
            ),
            b(str("metric2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric3"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric4"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("local-preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("priority"),
              (str("high") | str("medium") | str("low"))
            ),
            b(str("prefix-segment"),
                sc(
                    a(str("index"), arg),
                    str("node-segment")
                )
            ).as(:oneline),
            b(str("label-allocation"),
              (str("per-table") | str("per-nexthop") | str("per-table-localize"))
            ),
            b(str("add-path"),
                sc(
                    a(str("send-count"), arg)
                )
            ).as(:oneline),
            b(str("validation-state"),
              (str("valid") | str("invalid") | str("unknown"))
            ),
            b(str("origin"),
              (str("igp") | str("egp") | str("incomplete"))
            ),
            b(str("aigp-originate"),
                sc(
                    a(str("distance"), arg)
                )
            ).as(:oneline),
            b(str("aigp-adjust"),
                sc(
                    c(
                      str("add"),
                      str("subtract"),
                      str("multiply"),
                      str("divide")
                    ),
                    ca(
                      str("distance-to-protocol-nexthop")
                    )
                )
            ).as(:oneline),
            b(str("community"),
                s(
                  c(
                    a(str("="), arg),
                    a(str("set"), arg),
                    a(str("+"), arg),
                    a(str("add"), arg),
                    a(str("-"), arg),
                    a(str("delete"), arg)
                  ),
                        arg
                )
            ).as(:oneline),
            a(str("damping"), arg),
            str("aggregate-bandwidth"),
            a(str("limit-bandwidth"), arg),
            str("no-entropy-label-capability"),
            a(str("as-path-prepend"), quote | arg),
            b(str("as-path-expand"),
                sc(
                    c(
                      b(str("last-as"),
                          sc(
                              a(str("count"), arg)
                          )
                      ).as(:oneline),
                      arg
                    )
                )
            ).as(:oneline),
            b(str("next-hop"),
                sc(
                    c(
                      str("self"),
                      str("peer-address"),
                      str("reject"),
                      str("discard"),
                      a(str("next-table"), arg),
                        ipaddr
                    )
                )
            ).as(:oneline),
            b(str("install-nexthop"),
                sc(
                    c(
                      str("strict"),
                      str("strict-named-lsp")
                    ),
                    c(
                      a(str("lsp"), arg),
                      a(str("lsp-regex"), arg),
                      a(str("static-lsp"), arg),
                      a(str("static-lsp-regex"), arg),
                      str("non-lsp-nexthop"),
                      str("non-labelled-nexthop")
                    ),
                    b(str("except"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("fallback"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    ),
                                    b(str("except"),
                                        c(
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg),
                                              str("non-lsp-nexthop"),
                                              str("non-labelled-nexthop")
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("fallback"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("except"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    )
                                )
                            )
                        )
                    )
                )
            ).as(:oneline),
            str("trace"),
            b(str("external"),
                c(
                    a(str("type"), arg),
                    str("nssa-only")
                )
            ),
            b(str("load-balance"),
                sc(
                    c(
                      str("per-packet"),
                      str("random"),
                      str("per-prefix"),
                      str("consistent-hash"),
                      str("source-ip-only"),
                      str("destination-ip-only")
                    )
                )
            ).as(:oneline),
            str("no-route-localize"),
            str("install-to-fib"),
            str("no-install-to-fib"),
            str("analyze"),
            a(str("class"), arg),
            a(str("destination-class"), arg),
            a(str("source-class"), arg),
            a(str("forwarding-class"), arg),
            b(str("map-to-interface"),
                sc(
                    c(
                      str("self"),
                        interface_name
                    )
                )
            ).as(:oneline),
            b(str("ssm-source"),
              ipaddr
            ),
            b(str("p2mp-lsp-root"),
                c(
                    b(str("address"),
                      ipv4addr
                    )
                )
            ),
            a(str("cos-next-hop-map"), arg),
            a(str("dynamic-tunnel-attributes"), arg),
            str("selected-mldp-egress"),
            str("mhop-bfd-port"),
            str("no-backup"),
            b(str("default-action"),
              (str("accept") | str("reject"))
            ),
            b(str("next"),
              (str("policy") | str("term"))
            ),
            c(
              str("accept"),
              str("reject")
            ),
            b(str("bgp-output-queue-priority"),
                sc(
                    c(
                      a(str("priority"), arg),
                      str("expedited")
                    )
                )
            ).as(:oneline),
            str("multipath-resolve"),
            a(str("sr-te-template"), arg),
            str("label-allocation-fallback-reject"),
            a(str("resolution-map"), arg)
          )
        )
    end

    rule(:route_record_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("parse") | str("all"))).as(:oneline)
        )
    end

    rule(:routing_destinations) do
        c(
            a(str("default-availability-check-profile"), arg),
            b(str("availability-check-profiles"),
              availability_check_profile
            ),
            b(str("servers"),
              routing_destination_server
            ),
            b(str("clusters"),
              routing_destination_cluster
            )
        )
    end

    rule(:availability_check_profile) do
      b(arg.as(:arg),
        c(
            b(str("keepalive-method"),
                sc(
                    c(
                      str("sip-options")
                    )
                )
            ).as(:oneline),
            b(str("keepalive-strategy"),
                sc(
                    c(
                      b(str("send-always"),
                          c(
                              a(str("failures-before-unavailable"), arg),
                              a(str("successes-before-available"), arg)
                          )
                      ),
                      b(str("send-when-unavailable"),
                          sc(
                              a(str("successes-before-available"), arg)
                          )
                      ).as(:oneline),
                      b(str("do-not-send"),
                          sc(
                              a(str("blackout-period"), arg)
                          )
                      ).as(:oneline)
                    )
                )
            ).as(:oneline),
            b(str("keepalive-interval"),
                c(
                    a(str("available-server"), arg),
                    a(str("unavailable-server"), arg)
                )
            ),
            a(str("transaction-timeout"), arg)
        )
      )
    end

    rule(:routing_destination_cluster) do
      b(arg.as(:arg),
        c(
            b(a(str("server"), arg),
                c(
                    a(str("priority"), arg),
                    a(str("weight"), arg)
                )
            )
        )
      )
    end

    rule(:routing_destination_server) do
      b(arg.as(:arg),
        c(
            b(str("address"),
              routing_destination_address
            ),
            a(str("service-point"), arg),
            a(str("admission-control"), arg),
            a(str("availability-check-profile"), arg)
        )
      )
    end

    rule(:routing_destination_address) do
        c(
            a(str("port"), arg),
            b(str("transport-protocol"),
              transport_protocol
            ),
              ipaddr
        ).as(:oneline)
    end

    rule(:rpd_rib_group_type) do
      b(arg.as(:arg),
        c(
            a(str("export-rib"), arg),
            a(str("import-rib"), arg),
            b(str("import-policy"),
              policy_algebra
            )
        )
      )
    end

    rule(:rpm_next_hop) do
      b(arg.as(:arg),
        c(
            b(a(str("rpm-probe"), arg),
                sc(
                    a(str("rpm-test"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:rsmon_fpc_type) do
      b(arg.as(:arg),
        c(
            b(str("pic"),
              rsmon_pic_type
            ),
            a(str("limit"), arg)
        )
      )
    end

    rule(:rsmon_pic_type) do
      b(arg.as(:arg),
        c(
            b(str("port"),
              rsmon_port_type
            ),
            a(str("limit"), arg)
        )
      )
    end

    rule(:rsmon_port_type) do
      b(arg.as(:arg),
        c(
            a(str("limit"), arg)
        )
      )
    end

    rule(:rtf_prefix_list_items) do
      arg.as(:arg)
    end

    rule(:s6a_definition) do
        c(
            b(a(str("partition"), arg),
                c(
                    a(str("destination-realm"), arg),
                    a(str("destination-host"), arg),
                    a(str("diameter-instance"), arg),
                    a(str("max-outstanding-requests"), arg),
                    a(str("response-timeout"), arg)
                )
            )
        )
    end

    rule(:sampling_family_inet6_output_type) do
        c(
            a(str("aggregate-export-interval"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-active-timeout"), arg),
            b(str("flow-server"),
              cflowd_sampling_inet6_sampling_type
            ),
            b(str("interface"),
              packet_export_intf_type
            ),
            b(str("inline-jflow"),
              packet_export_inline
            ),
            a(str("extension-service"), arg)
        )
    end

    rule(:cflowd_sampling_inet6_sampling_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:packet_export_inline) do
        c(
            b(str("source-address"),
              ipaddr
            ),
            a(str("flow-export-rate"), arg)
        )
    end

    rule(:sampling_family_input_type) do
        c(
            a(str("rate"), arg),
            a(str("run-length"), arg),
            a(str("max-packets-per-second"), arg),
            a(str("maximum-packet-length"), arg)
        )
    end

    rule(:sampling_global_mpls_output_type) do
        c(
            a(str("aggregate-export-interval"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-active-timeout"), arg),
            b(str("flow-server"),
              cflowd_global_mpls_sampling_type
            ),
            b(str("interface"),
              packet_export_intf_type
            )
        )
    end

    rule(:cflowd_global_mpls_sampling_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:sampling_input_type) do
        c(
            a(str("rate"), arg),
            a(str("run-length"), arg),
            a(str("max-packets-per-second"), arg),
            a(str("maximum-packet-length"), arg),
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            a(str("rate"), arg),
                            a(str("run-length"), arg),
                            a(str("max-packets-per-second"), arg),
                            a(str("maximum-packet-length"), arg)
                        )
                    ),
                    b(str("mpls"),
                        c(
                            a(str("rate"), arg),
                            a(str("run-length"), arg),
                            a(str("max-packets-per-second"), arg),
                            a(str("maximum-packet-length"), arg)
                        )
                    ),
                    b(str("inet6"),
                        c(
                            a(str("rate"), arg),
                            a(str("run-length"), arg),
                            a(str("max-packets-per-second"), arg),
                            a(str("maximum-packet-length"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:sampling_instance_bridge_output_type) do
        c(
            b(str("flow-server"),
              cflowd_instance_bridge_sampling_type
            ),
            b(str("inline-jflow"),
              packet_export_inline_instance
            )
        )
    end

    rule(:cflowd_instance_bridge_sampling_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:packet_export_inline_instance) do
        c(
            b(str("source-address"),
              ipaddr
            ),
            a(str("flow-export-rate"), arg)
        )
    end

    rule(:sampling_instance_inet6_output_type) do
        c(
            a(str("aggregate-export-interval"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-active-timeout"), arg),
            b(str("flow-server"),
              cflowd_instance_inet6_sampling_type
            ),
            b(str("interface"),
              packet_export_intf_type
            ),
            b(str("inline-jflow"),
              packet_export_inline_instance
            ),
            a(str("extension-service"), arg)
        )
    end

    rule(:cflowd_instance_inet6_sampling_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:sampling_instance_inet_global_output_type) do
        c(
            a(str("aggregate-export-interval"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-active-timeout"), arg),
            b(str("file"),
                sc(
                      (str("disable")),
                    arg,
                    a(str("files"), arg),
                    a(str("size"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    str("stamp"),
                    str("no-stamp")
                )
            ).as(:oneline),
            b(str("port-mirroring"),
              inet_pm_family_output_type
            ),
            b(str("flow-server"),
              cflowd_sampling_inet_type
            ),
            b(str("interface"),
              packet_export_intf_type
            ),
            b(str("inline-jflow"),
              packet_export_inline
            ),
            a(str("extension-service"), arg)
        )
    end

    rule(:cflowd_sampling_inet_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version"),
              (str("5") | str("8") | str("500"))
            )
        )
      )
    end

    rule(:sampling_instance_inet_output_type) do
        c(
            a(str("aggregate-export-interval"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-active-timeout"), arg),
            b(str("flow-server"),
              cflowd_instance_inet_sampling_type
            ),
            b(str("interface"),
              packet_export_intf_type
            ),
            b(str("inline-jflow"),
              packet_export_inline_instance
            ),
            a(str("extension-service"), arg)
        )
    end

    rule(:cflowd_instance_inet_sampling_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version"),
              (str("5") | str("8"))
            )
        )
      )
    end

    rule(:sampling_instance_input_type) do
        c(
            a(str("rate"), arg),
            a(str("run-length"), arg),
            a(str("max-packets-per-second"), arg),
            a(str("maximum-packet-length"), arg)
        )
    end

    rule(:sampling_instance_mpls_output_type) do
        c(
            a(str("aggregate-export-interval"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-active-timeout"), arg),
            b(str("flow-server"),
              cflowd_instance_mpls_sampling_type
            ),
            b(str("interface"),
              packet_export_intf_type
            ),
            b(str("inline-jflow"),
              packet_export_inline_instance
            )
        )
    end

    rule(:cflowd_instance_mpls_sampling_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:sampling_instance_vpls_output_type) do
        c(
            b(str("flow-server"),
              cflowd_instance_vpls_sampling_type
            ),
            b(str("inline-jflow"),
              packet_export_inline_instance
            )
        )
    end

    rule(:cflowd_instance_vpls_sampling_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:sampling_output_type) do
        c(
            a(str("aggregate-export-interval"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-active-timeout"), arg),
            b(str("file"),
                sc(
                      (str("disable")),
                    arg,
                    a(str("files"), arg),
                    a(str("size"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    str("stamp"),
                    str("no-stamp")
                )
            ).as(:oneline),
            b(str("port-mirroring"),
              inet_pm_family_output_type
            ),
            b(str("flow-server"),
              cflowd_sampling_type
            ),
            b(str("interface"),
              packet_export_intf_type
            ),
            b(str("inline-jflow"),
              packet_export_inline
            ),
            a(str("extension-service"), arg)
        )
    end

    rule(:cflowd_sampling_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("dscp"), arg),
            a(str("forwarding-class"), arg),
            a(str("routing-instance"), arg),
            b(str("autonomous-system-type"),
              (str("origin") | str("peer"))
            ),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            b(str("version9"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version-ipfix"),
                c(
                    b(str("template"),
                        c(
                            arg
                        )
                    )
                )
            ),
            b(str("version"),
              (str("5") | str("8") | str("500"))
            )
        )
      )
    end

    rule(:sampling_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline)
        )
    end

    rule(:satellite_bridge_filter) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("source-mac-address"),
                              firewall_mac_addr_object
                            ),
                            b(str("destination-mac-address"),
                              firewall_mac_addr_object
                            ),
                            b(str("ip-source-address"),
                              firewall_addr_object
                            ),
                            b(str("ip-destination-address"),
                              firewall_addr_object
                            ),
                            c(
                              b(str("ip-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ip-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              a(str("user-vlan-id"), arg),
                              a(str("user-vlan-id-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              str("accept"),
                              str("discard")
                            ),
                            a(str("next-hop-group"), arg)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:satellite_policy_options) do
        c(
            b(a(str("extended-ports-template"), arg),
                c(
                    b(str("pic"),
                      satellite_pic_type
                    )
                )
            ),
            b(a(str("port-group-alias"), arg),
                c(
                    b(a(str("pic"), arg),
                        c(
                            a(str("port"), arg)
                        )
                    )
                )
            ),
            b(a(str("chassis-group-alias"), arg),
                c(
                    str("prefer-primary"),
                    b(a(str("chassis-id"), arg),
                        c(
                            b(str("mode"),
                                c(
                                    c(
                                      str("primary"),
                                      str("backup")
                                    )
                                )
                            ),
                            a(str("core-interface"), arg)
                        )
                    )
                )
            ),
            b(a(str("extended-ports-policy"), arg),
                c(
                    b(a(str("term"), arg),
                        c(
                            b(str("from"),
                                c(
                                    a(str("product-model"), arg),
                                    a(str("extended-ports-template"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("candidate-uplink-port-policy"), arg),
                c(
                    a(str("uplink-port-group"), arg),
                    a(str("minimum-links"), arg),
                    a(str("holddown"), arg),
                    b(a(str("term"), arg),
                        c(
                            b(str("from"),
                                c(
                                    a(str("product-model"), arg),
                                    a(str("uplink-port-group"), arg),
                                    a(str("minimum-links"), arg),
                                    a(str("holddown"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("environment-monitoring-policy"), arg),
                c(
                    b(str("alarm"),
                        c(
                            b(str("linkdown"),
                              (str("ignore") | str("red") | str("yellow"))
                            )
                        )
                    ),
                    b(a(str("term"), arg),
                        c(
                            b(str("from"),
                                c(
                                    a(str("product-model"), arg),
                                    b(str("alarm"),
                                        c(
                                            b(str("linkdown"),
                                              (str("ignore") | str("red") | str("yellow"))
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("forwarding-policy"), arg),
                c(
                    b(str("port-group-extended"),
                      port_extend_type
                    ),
                    b(a(str("term"), arg),
                        c(
                            b(str("from"),
                                c(
                                    a(str("product-model"), arg),
                                    b(str("port-group-extended"),
                                      port_extend_type
                                    )
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:port_extend_type) do
      b(arg.as(:arg),
        c(
            a(str("filter"), arg),
            b(str("port-group-uplink"),
                ca(
                    a(str("minimum-links"), arg),
                    a(str("holddown"), arg)
                )
            ),
            b(str("mirror-ingress"),
                c(
                    a(str("port-group-mirror"), arg)
                )
            ),
            b(str("mirror-egress"),
                c(
                    a(str("port-group-mirror"), arg)
                )
            )
        )
      )
    end

    rule(:satellite_pic_type) do
      b(arg.as(:arg),
        c(
            b(str("port"),
              satellite_pic_port_attr
            ),
            b(str("port-range"),
                s(
                        arg,
                        arg,
                  c(
                    b(str("channel-speed"),
                      (str("10g") | str("disable-auto-speed-detection"))
                    )
                  )
                )
            )
        )
      )
    end

    rule(:satellite_pic_port_attr) do
      b(arg.as(:arg),
        c(
            b(str("channel-speed"),
              (str("10g") | str("25g") | str("50g") | str("disable-auto-speed-detection"))
            )
        )
      )
    end

    rule(:sbc_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("flag"),
                c(
                    b(str("configuration"),
                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                    ),
                    b(str("ipc"),
                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                    ),
                    b(str("device-monitor"),
                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                    ),
                    b(str("ui"),
                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                    ),
                    b(str("common"),
                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                    ),
                    b(str("memory-pool"),
                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                    ),
                    b(str("packet-capture"),
                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                    ),
                    b(str("all"),
                      (str("trace") | str("debug") | str("info") | str("warning") | str("error"))
                    )
                )
            )
        )
    end

    rule(:script_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            a(str("flag"), enum(str("all") | str("events") | str("input") | str("offline") | str("output") | str("rpc") | str("xslt"))).as(:oneline)
        )
    end

    rule(:scripts_type) do
        c(
            b(str("commit"),
                c(
                    str("allow-transients"),
                    b(str("traceoptions"),
                      script_traceoptions
                    ),
                    str("refresh"),
                    a(str("refresh-from"), arg),
                    a(str("max-datasize"), arg),
                    str("direct-access"),
                    b(str("dampen"),
                        c(
                            b(str("dampen-options"),
                                c(
                                    a(str("cpu-factor"), arg),
                                    a(str("line-interval"), arg),
                                    a(str("time-interval"), arg)
                                )
                            )
                        )
                    ),
                    b(str("file"),
                      commit_scripts_file_type
                    )
                )
            ),
            b(str("op"),
                c(
                    str("refresh"),
                    a(str("refresh-from"), arg),
                    b(str("traceoptions"),
                      script_traceoptions
                    ),
                    b(str("file"),
                      op_scripts_file_type
                    ),
                    str("no-allow-url"),
                    str("allow-url-for-python"),
                    a(str("max-datasize"), arg),
                    b(str("dampen"),
                        c(
                            b(str("dampen-options"),
                                c(
                                    a(str("cpu-factor"), arg),
                                    a(str("line-interval"), arg),
                                    a(str("time-interval"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("translation"),
                c(
                    a(str("max-datasize"), arg)
                )
            ),
            str("load-scripts-from-flash"),
            b(str("language"),
              (str("python"))
            ),
            str("synchronize"),
            b(str("snmp"),
                c(
                    str("refresh"),
                    a(str("refresh-from"), arg),
                    b(str("file"),
                      snmp_scripts_file_type
                    ),
                    b(str("traceoptions"),
                      script_traceoptions
                    ),
                    a(str("max-datasize"), arg)
                )
            )
        )
    end

    rule(:commit_scripts_file_type) do
      b(arg.as(:arg),
        c(
            str("optional"),
            a(str("source"), arg),
            a(str("routing-instance"), arg),
            str("refresh"),
            a(str("refresh-from"), arg),
            b(str("checksum"),
                c(
                    a(str("sha-256"), arg)
                )
            )
        )
      )
    end

    rule(:op_scripts_file_type) do
      b(arg.as(:arg),
        c(
            a(str("command"), arg),
            b(str("dampen"),
                c(
                    b(str("dampen-options"),
                        c(
                            a(str("cpu-factor"), arg),
                            a(str("line-interval"), arg),
                            a(str("time-interval"), arg)
                        )
                    )
                )
            ),
            a(str("description"), quote | arg),
            a(str("source"), arg),
            a(str("routing-instance"), arg),
            b(str("allow-commands"),
              regular_expression
            ),
            str("refresh"),
            a(str("refresh-from"), arg),
            b(a(str("arguments"), arg),
                c(
                    a(str("description"), quote | arg)
                )
            ),
            b(str("checksum"),
                c(
                    a(str("sha-256"), arg)
                )
            )
        )
      )
    end

    rule(:sdk_mgmtd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("service-infrastructure") | str("routing-instance") | str("config-handling") | str("command-handling") | str("cli-show-commands") | str("all"))).as(:oneline)
        )
    end

    rule(:sdk_vmmd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("init") | str("configuration") | str("ccif") | str("pxe") | str("platform") | str("heartbeat") | str("routing-instances") | str("snmp") | str("miscellaneous") | str("all"))).as(:oneline)
        )
    end

    rule(:sec_object) do
        c(
            a(str("security-name"), arg),
            a(str("context"), arg)
        )
    end

    rule(:secintel_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("all") | str("feed") | str("ipc"))).as(:oneline)
        )
    end

    rule(:securid_server_object) do
      b(arg.as(:arg),
        c(
            a(str("configuration-file"), arg)
        )
      )
    end

    rule(:security_authentication_key_chains) do
        c(
            b(a(str("key-chain"), arg),
                c(
                    a(str("description"), quote | arg),
                    a(str("tolerance"), arg),
                    b(a(str("key"), arg),
                        c(
                            a(str("secret"), arg),
                            a(str("key-name"), arg),
                            b(str("start-time"),
                              time
                            ),
                            b(str("algorithm"),
                              (str("md5") | str("hmac-sha-1"))
                            ),
                            b(str("options"),
                              (str("basic") | str("isis-enhanced"))
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:security_dhcpv6_options_type) do
        c(
            b(str("option-37"),
                c(
                    b(str("prefix"),
                        c(
                            str("host-name"),
                            str("logical-system-name"),
                            str("routing-instance-name"),
                            str("vlan-name"),
                            str("vlan-id")
                        )
                    ),
                    str("use-interface-mac"),
                    b(str("use-interface-index"),
                      (str("logical") | str("device"))
                    ),
                    b(str("use-interface-name"),
                      (str("logical") | str("device"))
                    ),
                    b(str("use-interface-description"),
                      (str("logical") | str("device"))
                    ),
                    a(str("use-string"), arg)
                )
            ),
            b(str("option-18"),
                c(
                    b(str("prefix"),
                        c(
                            str("host-name"),
                            str("logical-system-name"),
                            str("routing-instance-name"),
                            str("vlan-name"),
                            str("vlan-id")
                        )
                    ),
                    str("use-interface-mac"),
                    b(str("use-interface-index"),
                      (str("logical") | str("device"))
                    ),
                    b(str("use-interface-name"),
                      (str("logical") | str("device"))
                    ),
                    b(str("use-interface-description"),
                      (str("logical") | str("device"))
                    ),
                    a(str("use-string"), arg)
                )
            ),
            b(str("option-16"),
                c(
                    a(str("use-string"), arg)
                )
            ),
            str("option-79")
        )
    end

    rule(:security_group_vpn) do
        c(
            b(str("member"),
              gvpn_member
            )
        )
    end

    rule(:gvpn_member) do
        c(
            b(str("ike"),
              gvpn_member_ike
            ),
            b(str("ipsec"),
              gvpn_member_ipsec_vpn
            )
        )
    end

    rule(:gvpn_member_ike) do
        c(
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    b(str("level"),
                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                    ),
                    a(str("flag"), enum(str("timer") | str("routing-socket") | str("parse") | str("config") | str("ike") | str("policy-manager") | str("general") | str("database") | str("certificates") | str("snmp") | str("thread") | str("high-availability") | str("next-hop-tunnels") | str("all"))).as(:oneline),
                    b(str("gateway-filter"),
                        c(
                            b(str("local-address"),
                              ipv4addr
                            ),
                            b(str("remote-address"),
                              ipv4addr
                            )
                        )
                    )
                )
            ),
            b(str("proposal"),
              gvpn_member_ike_proposal
            ),
            b(str("policy"),
              gvpn_ike_policy
            ),
            b(a(str("gateway"), arg),
                c(
                    a(str("ike-policy"), arg),
                    b(str("address"),
                      hostname
                    ),
                    b(str("server-address"),
                      ipv4addr
                    ),
                    b(str("local-identity"),
                        sc(
                            c(
                              b(str("inet"),
                                  c(
                                        ipv4addr
                                  )
                              ),
                              b(str("hostname"),
                                  c(
                                      arg
                                  )
                              ),
                              b(str("user-at-hostname"),
                                  c(
                                      arg
                                  )
                              ),
                              str("distinguished-name")
                            )
                        )
                    ).as(:oneline),
                    b(str("local-address"),
                      ipv4addr
                    ),
                    a(str("routing-instance"), arg)
                )
            )
        )
    end

    rule(:gvpn_ike_policy) do
      b(arg.as(:arg),
        c(
            b(str("mode"),
              (str("main") | str("aggressive"))
            ),
            a(str("description"), quote | arg),
            a(str("proposals"), arg),
            b(str("certificate"),
                c(
                    a(str("local-certificate"), arg),
                    b(str("trusted-ca"),
                        sc(
                            ca(
                              str("use-all")
                            )
                        )
                    ).as(:oneline),
                    b(str("peer-certificate-type"),
                      (str("pkcs7") | str("x509-signature"))
                    )
                )
            ),
            b(str("proposal-set"),
              (str("basic") | str("compatible") | str("standard"))
            ),
            b(str("pre-shared-key"),
                sc(
                    c(
                      a(str("ascii-text"), arg),
                      a(str("hexadecimal"), arg)
                    )
                )
            ).as(:oneline)
        )
      )
    end

    rule(:gvpn_member_ike_proposal) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("authentication-method"),
              (str("pre-shared-keys") | str("rsa-signatures") | str("dsa-signatures"))
            ),
            b(str("dh-group"),
              (str("group14") | str("group1") | str("group2") | str("group5"))
            ),
            b(str("authentication-algorithm"),
              (str("md5") | str("sha1") | str("sha-256"))
            ),
            b(str("encryption-algorithm"),
              (str("des-cbc") | str("3des-cbc") | str("aes-128-cbc") | str("aes-192-cbc") | str("aes-256-cbc"))
            ),
            a(str("lifetime-seconds"), arg)
        )
      )
    end

    rule(:gvpn_member_ipsec_vpn) do
        c(
            b(str("vpn"),
              ipsec_gvpn_member_template
            )
        )
    end

    rule(:ipsec_gvpn_member_template) do
      b(arg.as(:arg),
        c(
            a(str("ike-gateway"), arg),
            b(str("group-vpn-external-interface"),
              interface_name
            ),
            a(str("group"), arg),
            a(str("heartbeat-threshold"), arg),
            b(str("match-direction"),
              (str("input") | str("output"))
            ),
            a(str("tunnel-mtu"), arg),
            b(str("df-bit"),
              (str("clear") | str("set") | str("copy"))
            ),
            str("forward-policy-mismatch"),
            b(str("fail-open"),
              ipsec_gvpn_fail_open_rule_object
            )
        )
      )
    end

    rule(:ipsec_gvpn_fail_open_rule_object) do
        c(
            b(str("rule"),
              ipsec_gvpn_rule_address_object
            )
        )
    end

    rule(:ipsec_gvpn_rule_address_object) do
      b(arg.as(:arg),
        c(
            b(str("source-address"),
              ipsec_gvpn_addr_object
            ),
            b(str("destination-address"),
              ipsec_gvpn_addr_object
            )
        )
      )
    end

    rule(:ipsec_gvpn_addr_object) do
        c(
              ipv4prefix_only
        )
    end

    rule(:security_ike) do
        c(
            b(str("traceoptions"),
              security_traceoptions
            ),
            b(str("respond-bad-spi"),
                sc(
                      arg
                )
            ).as(:oneline),
            b(str("proposal"),
              ike_proposal
            ),
            b(str("policy"),
              ike_policy
            ),
            b(a(str("gateway"), arg),
                c(
                    a(str("ike-policy"), arg),
                    c(
                      b(str("address"),
                        (arg)
                      ),
                      b(str("dynamic"),
                          c(
                              c(
                                b(str("distinguished-name"),
                                    c(
                                        c(
                                          a(str("container"), arg),
                                          a(str("wildcard"), arg)
                                        )
                                    )
                                ),
                                a(str("hostname"), arg),
                                b(str("inet"),
                                  ipv4addr
                                ),
                                b(str("inet6"),
                                  ipv6addr
                                ),
                                a(str("user-at-hostname"), arg)
                              ),
                              a(str("connections-limit"), arg),
                              b(str("ike-user-type"),
                                (str("group-ike-id") | str("shared-ike-id"))
                              )
                          )
                      )
                    ),
                    b(str("dead-peer-detection"),
                        c(
                            str("always-send"),
                            a(str("interval"), arg),
                            a(str("threshold"), arg)
                        )
                    ),
                    str("no-nat-traversal"),
                    a(str("nat-keepalive"), arg),
                    b(str("local-identity"),
                        sc(
                            c(
                              b(str("inet"),
                                  c(
                                        ipv4addr
                                  )
                              ),
                              b(str("inet6"),
                                  c(
                                        ipv6addr
                                  )
                              ),
                              b(str("hostname"),
                                  c(
                                      arg
                                  )
                              ),
                              b(str("user-at-hostname"),
                                  c(
                                      arg
                                  )
                              ),
                              str("distinguished-name")
                            )
                        )
                    ).as(:oneline),
                    b(str("remote-identity"),
                        sc(
                            c(
                              b(str("inet"),
                                  c(
                                        ipv4addr
                                  )
                              ),
                              b(str("inet6"),
                                  c(
                                        ipv6addr
                                  )
                              ),
                              b(str("hostname"),
                                  c(
                                      arg
                                  )
                              ),
                              b(str("user-at-hostname"),
                                  c(
                                      arg
                                  )
                              ),
                              b(str("distinguished-name"),
                                  c(
                                      a(str("container"), arg),
                                      a(str("wildcard"), arg)
                                  )
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("external-interface"),
                      interface_unit
                    ),
                    b(str("xauth"),
                        sc(
                            a(str("access-profile"), arg)
                        )
                    ).as(:oneline),
                    str("general-ikeid"),
                    b(str("version"),
                      (str("v1-only") | str("v2-only"))
                    )
                )
            )
        )
    end

    rule(:ike_policy) do
      b(arg.as(:arg),
        c(
            b(str("mode"),
              (str("main") | str("aggressive"))
            ),
            a(str("description"), quote | arg),
            a(str("proposals"), arg),
            a(str("local-certificate"), arg),
            a(str("local-key-pair"), arg),
            b(str("encoding"),
              (str("binary") | str("pem"))
            ),
            a(str("identity"), arg),
            b(str("pre-shared-key"),
                sc(
                    c(
                      a(str("ascii-text"), arg),
                      a(str("hexadecimal"), arg)
                    )
                )
            ).as(:oneline)
        )
      )
    end

    rule(:ike_proposal) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("authentication-method"),
              (str("pre-shared-keys") | str("rsa-signatures") | str("dsa-signatures") | str("ecdsa-signatures-256") | str("ecdsa-signatures-384"))
            ),
            b(str("dh-group"),
              (str("group14") | str("group15") | str("group16") | str("group19") | str("group20") | str("group24") | str("group1") | str("group2") | str("group5"))
            ),
            b(str("authentication-algorithm"),
              (str("md5") | str("sha1") | str("sha-256") | str("sha-384"))
            ),
            b(str("encryption-algorithm"),
              (str("des-cbc") | str("3des-cbc") | str("aes-128-cbc") | str("aes-192-cbc") | str("aes-256-cbc"))
            ),
            a(str("lifetime-seconds"), arg)
        )
      )
    end

    rule(:security_ipsec_vpn) do
        c(
            b(str("traceoptions"),
              ipsec_traceoptions
            ),
            b(str("vpn-monitor-options"),
              ipsec_vpn_monitor
            ),
            b(str("proposal"),
              ipsec_proposal
            ),
            b(str("policy"),
              ipsec_policy
            ),
            b(str("vpn"),
              ipsec_vpn_template
            ),
            b(str("security-association"),
              ipsec_sa
            ),
            b(str("internal"),
                c(
                    b(str("security-association"),
                      ipsec_internal_sa
                    )
                )
            ),
            b(str("trusted-channel"),
                c(
                    b(str("security-association"),
                      ipsec_trusted_channel_sa
                    ),
                    a(str("port-exclusion-list"), arg)
                )
            )
        )
    end

    rule(:ipsec_internal_sa) do
        c(
            a(str("description"), quote | arg),
            b(str("manual"),
                c(
                    a(str("direction"), enum(str("inbound") | str("outbound") | str("bidirectional")),
                        c(
                            b(str("protocol"),
                              (str("ah") | str("esp") | str("bundle"))
                            ),
                            a(str("spi"), arg),
                            a(str("auxiliary-spi"), arg),
                            b(str("authentication"),
                                c(
                                    b(str("algorithm"),
                                      (str("hmac-md5-96") | str("hmac-sha1-96") | str("hmac-sha2-256") | str("hmac-sha-256-128"))
                                    ),
                                    b(str("key"),
                                        sc(
                                            c(
                                              a(str("ascii-text"), arg),
                                              a(str("hexadecimal"), arg)
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("encryption"),
                                c(
                                    b(str("algorithm"),
                                      (str("des-cbc") | str("3des-cbc") | str("aes-128-cbc") | str("aes-192-cbc") | str("aes-256-cbc"))
                                    ),
                                    b(str("key"),
                                        sc(
                                            c(
                                              a(str("ascii-text"), arg),
                                              a(str("hexadecimal"), arg)
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:ipsec_policy) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("perfect-forward-secrecy"),
                c(
                    b(str("keys"),
                      (str("group14") | str("group15") | str("group16") | str("group19") | str("group20") | str("group24") | str("group1") | str("group2") | str("group5"))
                    )
                )
            ),
            a(str("proposals"), arg),
            b(str("proposal-set"),
              (str("basic") | str("compatible") | str("standard"))
            )
        )
      )
    end

    rule(:ipsec_proposal) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("protocol"),
              (str("ah") | str("esp") | str("bundle"))
            ),
            b(str("authentication-algorithm"),
              (str("hmac-md5-96") | str("hmac-sha1-96") | str("hmac-sha-256-128") | str("hmac-sha-256-96") | str("hmac-sha2-256"))
            ),
            b(str("encryption-algorithm"),
              (str("des-cbc") | str("3des-cbc") | str("aes-128-cbc") | str("aes-192-cbc") | str("aes-256-cbc") | str("aes-128-gcm") | str("aes-192-gcm") | str("aes-256-gcm"))
            ),
            a(str("lifetime-seconds"), arg)
        )
      )
    end

    rule(:ipsec_sa) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("mode"),
              (str("transport") | str("tunnel"))
            ),
            c(
              b(str("manual"),
                  c(
                      a(str("direction"), enum(str("inbound") | str("outbound") | str("bidirectional")),
                          c(
                              b(str("protocol"),
                                (str("ah") | str("esp") | str("bundle"))
                              ),
                              a(str("spi"), arg),
                              a(str("auxiliary-spi"), arg),
                              b(str("authentication"),
                                  c(
                                      b(str("algorithm"),
                                        (str("hmac-md5-96") | str("hmac-sha1-96") | str("hmac-sha2-256") | str("hmac-sha-256-128"))
                                      ),
                                      b(str("key"),
                                          sc(
                                              c(
                                                a(str("ascii-text"), arg),
                                                a(str("hexadecimal"), arg)
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(str("encryption"),
                                  c(
                                      b(str("algorithm"),
                                        (str("des-cbc") | str("3des-cbc") | str("aes-128-cbc") | str("aes-192-cbc") | str("aes-256-cbc"))
                                      ),
                                      b(str("key"),
                                          sc(
                                              c(
                                                a(str("ascii-text"), arg),
                                                a(str("hexadecimal"), arg)
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("dynamic"),
                  c(
                      b(str("replay-window-size"),
                        (str("32") | str("64"))
                      ),
                      a(str("ipsec-policy"), arg)
                  )
              )
            )
        )
      )
    end

    rule(:ipsec_trusted_channel_sa) do
        c(
            a(str("description"), quote | arg),
            b(str("manual"),
                c(
                    a(str("direction"), enum(str("inbound") | str("outbound") | str("bidirectional")),
                        c(
                            b(str("protocol"),
                              (str("ah") | str("esp") | str("bundle"))
                            ),
                            a(str("spi"), arg),
                            a(str("auxiliary-spi"), arg),
                            b(str("authentication"),
                                c(
                                    b(str("algorithm"),
                                      (str("hmac-md5-96") | str("hmac-sha1-96") | str("hmac-sha2-256") | str("hmac-sha-256-128"))
                                    ),
                                    b(str("key"),
                                        sc(
                                            c(
                                              a(str("ascii-text"), arg),
                                              a(str("hexadecimal"), arg)
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("encryption"),
                                c(
                                    b(str("algorithm"),
                                      (str("des-cbc") | str("3des-cbc") | str("aes-128-cbc") | str("aes-192-cbc") | str("aes-256-cbc"))
                                    ),
                                    b(str("key"),
                                        sc(
                                            c(
                                              a(str("ascii-text"), arg),
                                              a(str("hexadecimal"), arg)
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:security_macsec) do
        c(
            b(str("traceoptions"),
              macsec_trace_options
            ),
            b(a(str("connectivity-association"), arg),
                c(
                    b(str("cipher-suite"),
                      (str("gcm-aes-128") | str("gcm-aes-256") | str("gcm-aes-xpn-128") | str("gcm-aes-xpn-256"))
                    ),
                    b(str("security-mode"),
                      (str("dynamic") | str("static-sak") | str("static-cak"))
                    ),
                    b(a(str("secure-channel"), arg),
                        c(
                            b(str("id"),
                                c(
                                    b(str("mac-address"),
                                      mac_addr
                                    ),
                                    a(str("port-id"), arg)
                                )
                            ),
                            b(str("direction"),
                              (str("inbound") | str("outbound"))
                            ),
                            str("encryption"),
                            b(str("offset"),
                              (str("0") | str("30") | str("50"))
                            ),
                            str("include-sci"),
                            b(a(str("security-association"), arg),
                                c(
                                    a(str("key"), arg)
                                )
                            )
                        )
                    ),
                    b(str("mka"),
                        c(
                            a(str("transmit-interval"), arg),
                            str("bounded-delay"),
                            a(str("key-server-priority"), arg),
                            str("must-secure"),
                            str("should-secure"),
                            b(str("eapol-address"),
                              (str("pae") | str("provider-bridge") | str("lldp-multicast") | arg)
                            )
                        )
                    ),
                    b(str("replay-protect"),
                        c(
                            a(str("replay-window-size"), arg)
                        )
                    ),
                    str("no-encryption"),
                    str("disable-preceding-key"),
                    b(str("offset"),
                      (str("0") | str("30") | str("50"))
                    ),
                    str("include-sci"),
                    b(str("pre-shared-key"),
                        c(
                            a(str("ckn"), arg),
                            a(str("cak"), arg)
                        )
                    ),
                    b(str("fallback-key"),
                        c(
                            a(str("ckn"), arg),
                            a(str("cak"), arg)
                        )
                    ),
                    a(str("pre-shared-key-chain"), arg),
                    a(str("exclude-protocol"), enum(str("cdp") | str("lldp") | str("lacp"))).as(:oneline)
                )
            ),
            b(a(str("interfaces"), arg),
                c(
                    b(a(str("unit"), arg),
                        c(
                            a(str("connectivity-association"), arg),
                            b(str("traceoptions"),
                              mka_trace_options
                            )
                        )
                    ),
                    a(str("connectivity-association"), arg),
                    str("aes-gcm-revert-flag"),
                    b(str("traceoptions"),
                      mka_trace_options
                    )
                )
            ),
            b(a(str("cluster-control-port"), arg),
                c(
                    a(str("connectivity-association"), arg),
                    b(str("traceoptions"),
                      mka_trace_options
                    )
                )
            ),
            b(a(str("cluster-data-port"), arg),
                c(
                    a(str("connectivity-association"), arg),
                    b(str("traceoptions"),
                      mka_trace_options
                    )
                )
            )
        )
    end

    rule(:macsec_trace_options) do
        c(
            b(str("file"),
                sc(
                      arg,
                    str("replace"),
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("no-stamp"),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            a(str("flag"), enum(str("config") | str("debug") | str("normal") | str("all"))).as(:oneline)
        )
    end

    rule(:mka_trace_options) do
        c(
            b(str("file"),
                sc(
                      arg,
                    str("replace"),
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("no-stamp"),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            a(str("flag"), enum(str("mka-packets") | str("state") | str("to-secy") | str("keys") | str("normal") | str("all"))).as(:oneline)
        )
    end

    rule(:security_model_access) do
      b(enum((str("any") | str("usm") | str("v1") | str("v2c"))).as(:arg),
        c(
            a(str("security-level"), enum(str("none") | str("authentication") | str("privacy")),
                c(
                    b(str("context-match"),
                      (str("exact") | str("prefix"))
                    ),
                    a(str("read-view"), arg),
                    a(str("write-view"), arg),
                    a(str("notify-view"), arg)
                )
            )
        )
      )
    end

    rule(:security_option_82_type) do
        c(
            b(str("circuit-id"),
                c(
                    b(str("prefix"),
                        c(
                            str("host-name"),
                            str("logical-system-name"),
                            str("routing-instance-name")
                        )
                    ),
                    b(str("use-interface-description"),
                      (str("logical") | str("device"))
                    ),
                    str("use-vlan-id")
                )
            ),
            b(str("remote-id"),
                c(
                    str("host-name"),
                    b(str("use-interface-description"),
                      (str("logical") | str("device"))
                    ),
                    a(str("use-string"), arg),
                    str("mac")
                )
            ),
            b(str("vendor-id"),
                c(
                    a(str("use-string"), arg)
                )
            )
        )
    end

    rule(:security_pki) do
        c(
            b(a(str("ca-profile"), arg),
                c(
                    a(str("ca-identity"), arg),
                    b(str("source-address"),
                      ipaddr
                    ),
                    a(str("proxy-profile"), arg),
                    a(str("routing-instance"), arg),
                    b(str("enrollment"),
                        c(
                            a(str("url"), arg),
                            a(str("retry"), arg),
                            a(str("retry-interval"), arg)
                        )
                    ),
                    b(str("revocation-check"),
                        c(
                            c(
                              str("use-crl"),
                              str("use-ocsp"),
                              str("disable")
                            ),
                            b(str("ocsp"),
                                c(
                                    a(str("url"), arg),
                                    b(str("nonce-payload"),
                                      (str("enable") | str("disable"))
                                    ),
                                    str("disable-responder-revocation-check"),
                                    str("accept-unknown-status"),
                                    b(str("connection-failure"),
                                        c(
                                            c(
                                              str("fallback-crl"),
                                              str("disable")
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("crl"),
                                c(
                                    b(str("disable"),
                                        sc(
                                            str("on-download-failure")
                                        )
                                    ).as(:oneline),
                                    b(a(str("url"), arg),
                                        c(
                                            b(str("password"),
                                              unreadable
                                            )
                                        )
                                    ),
                                    a(str("refresh-interval"), arg)
                                )
                            )
                        )
                    ),
                    b(str("administrator"),
                        c(
                            a(str("email-address"), arg)
                        )
                    )
                )
            ),
            b(a(str("trusted-ca-group"), arg),
                c(
                    a(str("ca-profiles"), arg)
                )
            ),
            b(str("auto-re-enrollment"),
                c(
                    b(str("cmpv2"),
                        c(
                            b(a(str("certificate-id"), arg),
                                c(
                                    a(str("ca-profile-name"), arg),
                                    a(str("re-enroll-trigger-time-percentage"), arg),
                                    str("re-generate-keypair")
                                )
                            )
                        )
                    ),
                    b(str("scep"),
                        c(
                            b(a(str("certificate-id"), arg),
                                c(
                                    a(str("ca-profile-name"), arg),
                                    str("re-generate-keypair"),
                                    a(str("re-enroll-trigger-time-percentage"), arg),
                                    b(str("challenge-password"),
                                      unreadable
                                    ),
                                    b(str("scep-encryption-algorithm"),
                                        c(
                                            c(
                                              str("des"),
                                              str("des3")
                                            )
                                        )
                                    ),
                                    b(str("scep-digest-algorithm"),
                                        c(
                                            c(
                                              str("md5"),
                                              str("sha1")
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("certificate-id"), arg),
                        c(
                            a(str("ca-profile-name"), arg),
                            str("re-generate-keypair"),
                            a(str("re-enroll-trigger-time-percentage"), arg),
                            b(str("challenge-password"),
                              unreadable
                            ),
                            b(str("scep-encryption-algorithm"),
                                c(
                                    c(
                                      str("des"),
                                      str("des3")
                                    )
                                )
                            ),
                            b(str("scep-digest-algorithm"),
                                c(
                                    c(
                                      str("md5"),
                                      str("sha1")
                                    )
                                )
                            ),
                            a(str("validity-period"), arg)
                        )
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("certificate-verification") | str("online-crl-check") | str("enrollment") | str("all"))).as(:oneline)
                )
            )
        )
    end

    rule(:security_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("rate-limit"), arg),
            b(str("filter"),
                c(
                    a(str("fpc"), arg),
                    a(str("pic"), arg)
                )
            ),
            a(str("flag"), enum(str("timer") | str("routing-socket") | str("parse") | str("config") | str("ike") | str("policy-manager") | str("general") | str("database") | str("certificates") | str("snmp") | str("thread") | str("high-availability") | str("next-hop-tunnels") | str("all") | str("ams") | str("lic"))).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            )
        )
    end

    rule(:server_active_leasequery_type) do
        c(
            a(str("timeout"), arg),
            a(str("idle-timeout"), arg)
        )
    end

    rule(:server_bulk_leasequery_type) do
        c(
            a(str("max-connections"), arg),
            a(str("timeout"), arg),
            a(str("max-empty-replies"), arg),
            str("restricted-requestor")
        )
    end

    rule(:server_group_type) do
        s(arg, arg)
    end

    rule(:server_leasequery_type) do
        c(
            str("restricted-requestor")
        )
    end

    rule(:server_match_action_choice) do
        c(
            c(
              str("forward-only"),
              str("create-relay-entry")
            )
        )
    end

    rule(:server_match_v6_ascii_hex) do
        c(
            b(a(str("ascii"), arg),
                c(
                    c(
                      str("forward-only"),
                      str("create-relay-entry")
                    )
                )
            ),
            b(a(str("hexadecimal"), arg),
                c(
                    c(
                      str("forward-only"),
                      str("create-relay-entry")
                    )
                )
            )
        )
    end

    rule(:server_v6_option_ascii_hex) do
        c(
            a(str("ascii"), arg),
            a(str("hexadecimal"), arg)
        )
    end

    rule(:service_device_object) do
      b(arg.as(:arg),
        c(
            b(str("address"),
              ipv4addr
            ),
            b(str("access-domain"),
                c(
                    a(str("vlan-id-list"), arg)
                )
            ),
            b(str("provisioning-method"),
                c(
                    c(
                      b(str("netconf"),
                        netconf_object
                      )
                    )
                )
            ),
            b(str("dictionary"),
                c(
                      filename
                )
            )
        )
      )
    end

    rule(:netconf_object) do
        c(
            a(str("user-name"), arg),
            a(str("password"), arg),
            a(str("connection-retry-interval"), arg),
            a(str("response-timeout"), arg),
            a(str("response-timeout-count"), arg),
            a(str("bulk-interval"), arg),
            a(str("bulk-limit"), arg),
            a(str("reconfigure-bulk-limit"), arg),
            a(str("port"), arg)
        )
    end

    rule(:service_device_pool_object) do
      b(arg.as(:arg),
        c(
            a(str("interface"), arg)
        )
      )
    end

    rule(:service_interface_pool_object) do
      b(arg.as(:arg),
        c(
            a(str("interface"), arg)
        )
      )
    end

    rule(:service_point_type) do
      b(arg.as(:arg),
        c(
            b(str("service-point-type"),
              (str("sip"))
            ),
            b(str("transport-details"),
                sc(
                    a(str("port-number"), arg),
                    b(str("ip-address"),
                      ipaddr
                    ),
                    str("tcp"),
                    str("udp"),
                    a(str("fqdn"), arg)
                )
            ).as(:oneline),
            b(str("service-interface"),
              interface_unit
            ),
            b(str("service-policies"),
              service_policies_type
            ),
            a(str("default-media-realm"), arg)
        )
      )
    end

    rule(:service_policies_type) do
        c(
            a(str("new-transaction-input-policies"), arg),
            a(str("new-transaction-output-policies"), arg),
            a(str("new-registration-input-policies"), arg),
            a(str("new-call-usage-input-policies"), arg),
            a(str("new-call-usage-output-policies"), arg)
        )
    end

    rule(:service_set_ipsec_vpn_options_object) do
        c(
            a(str("trusted-ca"), arg),
            b(str("local-gateway"),
                sc(
                    a(str("routing-instance"), arg),
                    b(str("interface"),
                      interface_unit
                    ),
                    b(str("gw-interface"),
                      interface_unit
                    ),
                      ipaddr
                )
            ).as(:oneline),
            a(str("ike-access-profile"), arg),
            str("passive-mode-tunneling"),
            str("clear-dont-fragment-bit"),
            str("copy-dont-fragment-bit"),
            str("set-dont-fragment-bit"),
            a(str("tunnel-mtu"), arg),
            str("no-anti-replay"),
            a(str("anti-replay-window-size"), arg),
            b(str("udp-encapsulate"),
                sc(
                    a(str("dest-port"), arg)
                )
            ).as(:oneline),
            str("no-nat-traversal"),
            a(str("nat-keepalive"), arg),
            str("no-certificate-chain-in-ike")
        )
    end

    rule(:services_ike) do
        c(
            b(str("proposal"),
              ike_proposal
            ),
            b(str("policy"),
              svc_ike_policy
            )
        )
    end

    rule(:services_ipsec) do
        c(
            b(str("proposal"),
              ipsec_proposal
            ),
            b(str("policy"),
              ipsec_policy
            )
        )
    end

    rule(:services_pcef) do
        c(
            b(str("traceoptions"),
              pcef_traceoptions
            ),
            b(str("event-trigger-profiles"),
                c(
                      evt_trigger_profile
                )
            ),
            b(str("flow-descriptions"),
                c(
                      pcc_flow
                )
            ),
            b(str("pcc-action-profiles"),
                c(
                      pcc_action_profile
                )
            ),
            b(str("pcc-rules"),
                c(
                      pcc_rule
                )
            ),
            b(str("pcc-rulebases"),
                c(
                      pcc_rulebase
                )
            ),
            b(str("profile"),
                c(
                      pcef_profiles
                )
            )
        )
    end

    rule(:evt_trigger_profile) do
      b(arg.as(:arg),
        c(
            str("rat-change"),
            str("sgsn-change"),
            str("plmn-change"),
            str("ip-can-change"),
            str("tft-change"),
            str("rai-change"),
            str("user-location-change"),
            str("ue-timezone-change")
        )
      )
    end

    rule(:pcc_action_profile) do
      b(arg.as(:arg),
        c(
            a(str("logging-rule"), arg),
            b(str("maximum-bit-rate"),
                sc(
                    a(str("uplink"), arg),
                    a(str("downlink"), arg)
                )
            ).as(:oneline),
            b(str("burst-size"),
                c(
                    a(str("uplink"), arg),
                    a(str("downlink"), arg)
                )
            ),
            b(str("gate-status"),
              (str("uplink") | str("downlink") | str("uplink-downlink") | str("disable-both"))
            ),
            b(str("charging"),
                c(
                    a(str("rating-group"), arg),
                    a(str("service-identifier"), arg),
                    b(str("charging-method"),
                      (str("online") | str("offline") | str("both") | str("none"))
                    ),
                    b(str("measurement-method"),
                      (str("none") | str("volume") | str("time") | str("volume-time") | str("event"))
                    ),
                    b(str("application-function-record-info"),
                        c(
                            a(str("af-charging-identifier"), arg)
                        )
                    ),
                    str("service-id-level-reporting")
                )
            ),
            b(str("redirect"),
                c(
                    a(str("url"), arg)
                )
            ),
            b(str("forwarding-class"),
                c(
                    arg
                )
            ),
            b(str("steering"),
                c(
                    b(str("routing-instance"),
                        sc(
                            a(str("uplink"), arg),
                            a(str("downlink"), arg)
                        )
                    ).as(:oneline),
                    b(str("path"),
                        sc(
                            c(
                              b(str("ipv4-address"),
                                ipv4prefix
                              ),
                              b(str("ipv6-address"),
                                ipv6prefix
                              )
                            )
                        )
                    ).as(:oneline),
                    str("keep-existing-steering")
                )
            ),
            b(str("hcm-profile"),
                c(
                    arg
                )
            ),
            a(str("monitoring-key"), arg)
        )
      )
    end

    rule(:pcc_flow) do
      b(arg.as(:arg),
        c(
            b(str("direction"),
              (str("downlink") | str("uplink") | str("both"))
            ),
            a(str("protocol"), arg),
            a(str("local-ports"), arg),
            b(str("local-port-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg)
                )
            ).as(:oneline),
            a(str("remote-ports"), arg),
            b(str("remote-port-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg)
                )
            ).as(:oneline),
            b(str("remote-address"),
                sc(
                    c(
                      b(str("ipv4-address"),
                        ipv4prefix
                      ),
                      b(str("ipv6-address"),
                        ipv6prefix
                      )
                    )
                )
            ).as(:oneline)
        )
      )
    end

    rule(:pcc_rule) do
      b(arg.as(:arg),
        c(
            b(str("from"),
                c(
                    a(str("flows"), arg),
                    a(str("applications"), arg),
                    a(str("nested-applications"), arg),
                    a(str("application-groups"), arg)
                )
            ),
            b(str("then"),
                c(
                    a(str("pcc-action-profile"), arg)
                )
            )
        )
      )
    end

    rule(:pcc_rulebase) do
      b(arg.as(:arg),
        c(
            b(a(str("pcc-rule"), arg),
                sc(
                    a(str("precedence"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:pcef_profiles) do
      b(arg.as(:arg),
        c(
            a(str("control-byte-rating-group"), arg),
            b(str("unresolved-flow-action"),
              (str("forward") | str("drop"))
            ),
            b(str("maximum-per-pdn-service-flows"),
                sc(
                    arg
                )
            ).as(:oneline),
            b(str("dynamic-policy-control"),
                c(
                    b(str("pcc-rules"),
                        c(
                              profile_rule_assoc
                        )
                    ),
                    a(str("pcc-rulebases"), arg),
                    a(str("diameter-profile"), arg),
                    a(str("event-trigger-profile"), arg),
                    str("session-failover-not-supported"),
                    b(str("release"),
                      (str("r8") | str("r9"))
                    )
                )
            ),
            b(str("static-policy-control"),
                c(
                    b(str("pcc-rules"),
                        c(
                              profile_static_rule_association
                        )
                    ),
                    b(a(str("pcc-rulebases"), arg),
                        c(
                            a(str("time-of-day-profile"), arg)
                        )
                    ),
                    a(str("activate-dedicated-bearers"), arg)
                )
            ),
            b(str("aaa-policy-control"),
                c(
                    a(str("profile"), arg),
                    a(str("user-password"), arg),
                    a(str("pcc-rulebases"), arg)
                )
            )
        )
      )
    end

    rule(:pcef_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("init") | str("config") | str("general") | str("high-availability") | str("debug") | str("fsm") | str("tftmgr") | str("all"))).as(:oneline)
        )
    end

    rule(:profile_rule_assoc) do
      b(arg.as(:arg),
        c(
            a(str("precedence"), arg)
        )
      ).as(:oneline)
    end

    rule(:profile_static_rule_association) do
      b(arg.as(:arg),
        c(
            a(str("precedence"), arg),
            a(str("time-of-day-profile"), arg),
            b(str("pcc-action-profile"),
                sc(
                      arg
                )
            ).as(:oneline)
        )
      ).as(:oneline)
    end

    rule(:sfw_addr_object) do
      b((str("any-unicast") | str("any-ipv4") | str("any-ipv6") | arg).as(:arg),
        c(
            str("except")
        )
      ).as(:oneline)
    end

    rule(:sfw_match_object) do
        c(
            b(str("source-address"),
              sfw_addr_object
            ),
            b(str("destination-address"),
              sfw_addr_object
            ),
            b(str("destination-port"),
                c(
                    c(
                      b(str("range"),
                          sc(
                              a(str("low"), arg),
                              a(str("high"), arg)
                          )
                      ).as(:oneline)
                    )
                )
            ),
            b(str("source-address-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg),
                  c(
                    str("except")
                  )
                )
            ).as(:oneline),
            b(a(str("source-prefix-list"), arg),
                sc(
                    str("except")
                )
            ).as(:oneline),
            b(str("destination-address-range"),
                s(
                  a(str("low"), arg),
                  a(str("high"), arg),
                  c(
                    str("except")
                  )
                )
            ).as(:oneline),
            b(a(str("destination-prefix-list"), arg),
                sc(
                    str("except")
                )
            ).as(:oneline),
            a(str("applications"), arg),
            a(str("application-sets"), arg),
            a(str("application"), arg)
        )
    end

    rule(:sfw_rule_object) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("input") | str("output") | str("input-output"))
            ),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      sfw_match_object
                    ),
                    b(str("then"),
                        c(
                            c(
                              str("accept"),
                              str("discard"),
                              str("reject")
                            ),
                            b(str("allow-ip-options"),
                                  (str("any") | str("strict-source-route") | str("loose-source-route") | str("route-record") | str("timestamp") | str("router-alert") | str("security") | str("stream-id") | arg)
                            ),
                            str("syslog"),
                            str("skip-ids")
                        )
                    )
                )
            )
        )
      )
    end

    rule(:sgw_config_gtp) do
        c(
            a(str("peer-history"), arg),
            b(str("interface"),
                sc(
                      interface_name,
                    b(str("v4-address"),
                      ipv4addr
                    )
                )
            ).as(:oneline),
            a(str("echo-interval"), arg),
            b(str("path-management"),
              (str("enable") | str("disable"))
            ),
            a(str("echo-n3-requests"), arg),
            a(str("echo-t3-response"), arg),
            b(str("path-failure"),
              (str("enable") | str("disable"))
            ),
            a(str("number-of-msgs-for-response-time"), arg),
            b(str("control"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    a(str("forwarding-class"), arg),
                    a(str("n3-requests"), arg),
                    a(str("t3-response"), arg),
                    a(str("dscp-code-point"), arg),
                    a(str("ttl-value"), arg),
                    b(str("ddn-delay-sync"),
                      (str("enable") | str("disable"))
                    ),
                    str("no-response-cache"),
                    a(str("response-cache-timeout"), arg),
                    str("no-piggyback-support")
                )
            ),
            b(str("data"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("num-gtpu-end-markers"), arg),
                    b(str("indirect-tunnel"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("error-indication-interval"), arg)
                )
            ),
            b(str("s1u"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    )
                )
            ),
            b(str("s11"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    a(str("forwarding-class"), arg),
                    a(str("n3-requests"), arg),
                    a(str("t3-response"), arg),
                    a(str("dscp-code-point"), arg),
                    a(str("ttl-value"), arg)
                )
            ),
            b(str("s12"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    )
                )
            ),
            b(str("s4"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    b(str("control"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("n3-requests"), arg),
                            a(str("t3-response"), arg),
                            a(str("dscp-code-point"), arg),
                            a(str("ttl-value"), arg)
                        )
                    ),
                    b(str("data"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            )
                        )
                    )
                )
            ),
            b(str("s5"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    b(str("control"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("n3-requests"), arg),
                            a(str("t3-response"), arg),
                            a(str("dscp-code-point"), arg),
                            a(str("ttl-value"), arg)
                        )
                    ),
                    b(str("data"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            )
                        )
                    )
                )
            ),
            b(str("s8"),
                c(
                    b(str("interface"),
                        sc(
                              interface_name,
                            b(str("v4-address"),
                              ipv4addr
                            )
                        )
                    ).as(:oneline),
                    a(str("echo-interval"), arg),
                    b(str("path-management"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("echo-n3-requests"), arg),
                    a(str("echo-t3-response"), arg),
                    b(str("path-failure"),
                      (str("enable") | str("disable"))
                    ),
                    a(str("number-of-msgs-for-response-time"), arg),
                    b(str("control"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("number-of-msgs-for-response-time"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("n3-requests"), arg),
                            a(str("t3-response"), arg),
                            a(str("dscp-code-point"), arg),
                            a(str("ttl-value"), arg)
                        )
                    ),
                    b(str("data"),
                        c(
                            b(str("interface"),
                                sc(
                                      interface_name,
                                    b(str("v4-address"),
                                      ipv4addr
                                    )
                                )
                            ).as(:oneline),
                            a(str("echo-interval"), arg),
                            b(str("path-management"),
                              (str("enable") | str("disable"))
                            ),
                            a(str("echo-n3-requests"), arg),
                            a(str("echo-t3-response"), arg),
                            b(str("path-failure"),
                              (str("enable") | str("disable"))
                            )
                        )
                    )
                )
            ),
            b(str("traceoptions"),
              gtp_traceoptions
            )
        )
    end

    rule(:sgw_idle_mode_buffering) do
        c(
            str("disable"),
            a(str("expire-timer"), arg)
        )
    end

    rule(:signaling_realm) do
      arg.as(:arg)
    end

    rule(:sip_timers_type) do
        c(
            a(str("inactive-call"), arg),
            a(str("timer-c"), arg)
        )
    end

    rule(:slaacd_config_type) do
        c(
            b(str("vlans"),
                c(
                      vlan_slaacd
                )
            ),
            b(str("interface"),
                c(
                      slaacd_interface
                )
            ),
            b(str("link-local-expiry-interval"),
                c(
                      arg
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("configuration") | str("init") | str("state") | str("rtsock") | str("packet") | str("fsm") | str("io") | str("verbose") | str("task") | str("all"))).as(:oneline)
                )
            )
        )
    end

    rule(:slaacd_interface) do
      b((str("all") | arg).as(:arg),
        c(
            b(str("mark-interface"),
                c(
                    str("trusted")
                )
            ),
            b(str("max-allowed-contention"),
                c(
                    a(str("count"), arg),
                    a(str("duration"), arg)
                )
            ),
            b(str("auto-dad"),
                c(
                    a(str("retries"), arg),
                    a(str("retrans-interval"), arg)
                )
            )
        )
      )
    end

    rule(:sm_ippool_pool) do
      b(arg.as(:arg),
        c(
            b(str("service-mode"),
              (str("maintenance"))
            ),
            b(str("family"),
                c(
                    c(
                      b(str("inet"),
                          c(
                              b(a(str("network"), arg),
                                  c(
                                      str("external-assigned"),
                                      a(str("allocation-prefix-length"), arg),
                                      b(a(str("range"), arg),
                                          c(
                                              b(str("low"),
                                                ipv4addr
                                              ),
                                              b(str("high"),
                                                ipv4addr
                                              ),
                                              str("external-assigned")
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("inet6"),
                          c(
                              b(a(str("network"), arg),
                                  c(
                                      str("external-assigned"),
                                      a(str("allocation-prefix-length"), arg),
                                      b(a(str("range"), arg),
                                          c(
                                              b(str("low"),
                                                ipv6prefix_only
                                              ),
                                              b(str("high"),
                                                ipv6prefix_only
                                              ),
                                              str("external-assigned")
                                          )
                                      )
                                  )
                              )
                          )
                      )
                    )
                )
            ),
            a(str("ageing-window"), arg),
            a(str("pool-prefetch-threshold"), arg),
            a(str("pool-snmp-trap-threshold"), arg),
            str("default-pool")
        )
      )
    end

    rule(:smid_type) do
        c(
            b(str("traceoptions"),
              smid_traceoptions_type
            ),
            b(str("maintain-subscriber"),
              smid_maintain_subscriber_type
            ),
            str("gres-route-flush-delay"),
            str("enforce-strict-scale-limit-license"),
            b(str("overrides"),
                c(
                    str("no-unsolicited-ra"),
                    b(str("interfaces"),
                        c(
                            b(str("family"),
                                c(
                                    b(str("inet6"),
                                        c(
                                            str("layer2-liveness-detection")
                                        )
                                    ),
                                    b(str("inet"),
                                        c(
                                            str("layer2-liveness-detection"),
                                            str("receive-gratuitous-arp"),
                                            str("ipoe-dynamic-arp-enable")
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("shmlog"),
                        c(
                            str("disable"),
                            b(str("filtering"),
                                c(
                                    str("enable")
                                )
                            ),
                            b(str("file"),
                                sc(
                                      arg,
                                    a(str("size"), arg),
                                    a(str("files"), arg)
                                )
                            ).as(:oneline),
                            a(str("log-name"), str("all") | arg,
                                c(
                                    c(
                                      str("none"),
                                      str("terse"),
                                      str("brief"),
                                      str("detail"),
                                      str("extensive")
                                    ),
                                    c(
                                      str("file-logging"),
                                      str("no-file-logging")
                                    )
                                )
                            ),
                            a(str("log-type"), enum(str("debug") | str("info") | str("notice")),
                                c(
                                    c(
                                      str("none"),
                                      str("terse"),
                                      str("brief"),
                                      str("detail"),
                                      str("extensive")
                                    ),
                                    c(
                                      str("file-logging"),
                                      str("no-file-logging")
                                    )
                                )
                            )
                        )
                    ),
                    b(str("event"),
                        c(
                            b(str("catastrophic-failure"),
                                c(
                                    b(str("reboot"),
                                        c(
                                            b(str("routing-engine-specifiers"),
                                                  (str("master") | str("standby"))
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            str("enable"),
            b(str("redundancy"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("virtual-inet-address"),
                              ipaddr
                            ),
                            b(str("virtual-inet6-address"),
                              ipaddr
                            )
                        )
                    ),
                    b(str("protocol"),
                        c(
                            c(
                              str("vrrp")
                            )
                        )
                    ),
                    str("re-authenticate-on-failover"),
                    str("no-advertise-routes-on-backup")
                )
            )
        )
    end

    rule(:smid_maintain_subscriber_type) do
        c(
            str("interface-delete")
        )
    end

    rule(:smid_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("database") | str("ui") | str("general") | str("session-db") | str("server") | str("issu") | str("all"))).as(:oneline)
        )
    end

    rule(:smihelperd_type) do
        c(
            b(str("traceoptions"),
              smihelperd_traceoptions_type
            )
        )
    end

    rule(:smihelperd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("sdb") | str("general") | str("ui") | str("snmp") | str("all"))).as(:oneline)
        )
    end

    rule(:smpl_analyzer_type) do
      b(arg.as(:arg),
        c(
            b(str("input"),
              smpl_analyzer_input_type
            ),
            b(str("output"),
              smpl_analyzer_output_type
            )
        )
      )
    end

    rule(:smpl_analyzer_input_type) do
        c(
            a(str("rate"), arg),
            a(str("maximum-packet-length"), arg),
            b(str("ingress"),
              smpl_analyzer_ingress_type
            ),
            b(str("egress"),
              smpl_analyzer_egress_type
            )
        )
    end

    rule(:smpl_analyzer_egress_type) do
        c(
            b(str("interface"),
              analyzer_egress_interface_type
            ),
            b(str("routing-instance"),
              analyzer_egress_routing_instance_type
            ),
            b(str("vlan"),
              analyzer_egress_vlan_type
            ),
            b(str("bridge-domain"),
              analyzer_egress_bridge_domain_type
            )
        )
    end

    rule(:analyzer_egress_bridge_domain_type) do
      arg.as(:arg)
    end

    rule(:analyzer_egress_interface_type) do
      (str("all") | arg).as(:arg)
    end

    rule(:analyzer_egress_routing_instance_type) do
      b(arg.as(:arg),
        c(
            b(str("vlan"),
              analyzer_egress_vlan_type
            ),
            b(str("bridge-domain"),
              analyzer_egress_bridge_domain_type
            )
        )
      )
    end

    rule(:analyzer_egress_vlan_type) do
      arg.as(:arg)
    end

    rule(:smpl_analyzer_ingress_type) do
        c(
            b(str("interface"),
              analyzer_ingress_interface_type
            ),
            b(str("routing-instance"),
              analyzer_ingress_routing_instance_type
            ),
            b(str("vlan"),
              analyzer_ingress_vlan_type
            ),
            b(str("bridge-domain"),
              analyzer_ingress_bridge_domain_type
            )
        )
    end

    rule(:analyzer_ingress_bridge_domain_type) do
      arg.as(:arg)
    end

    rule(:analyzer_ingress_interface_type) do
      (str("all") | arg).as(:arg)
    end

    rule(:analyzer_ingress_routing_instance_type) do
      b(arg.as(:arg),
        c(
            b(str("vlan"),
              analyzer_ingress_vlan_type
            ),
            b(str("bridge-domain"),
              analyzer_ingress_bridge_domain_type
            )
        )
      )
    end

    rule(:analyzer_ingress_vlan_type) do
      arg.as(:arg)
    end

    rule(:smpl_analyzer_output_type) do
        c(
            c(
              b(str("interface"),
                interface_name
              ),
              b(str("ip-address"),
                ipv4addr
              ),
              a(str("next-hop-group"), arg),
              b(str("routing-instance"),
                output_routing_instance_type
              ),
              b(str("vlan"),
                pm_rspan_vlan
              ),
              b(str("bridge-domain"),
                pm_rspan_bridge_domain
              )
            )
        )
    end

    rule(:output_routing_instance_type) do
      b(arg.as(:arg),
        c(
            c(
              b(str("ip-address"),
                ipv4addr
              ),
              b(str("vlan"),
                pm_rspan_vlan
              ),
              b(str("bridge-domain"),
                pm_rspan_bridge_domain
              )
            )
        )
      )
    end

    rule(:snmp_scripts_file_type) do
      b(arg.as(:arg),
        c(
            b(a(str("oid"), arg),
                c(
                    a(str("priority"), arg)
                )
            ),
            a(str("source"), arg),
            a(str("routing-instance"), arg),
            a(str("python-script-user"), arg),
            str("refresh"),
            a(str("refresh-from"), arg),
            b(str("checksum"),
                c(
                    a(str("sha-256"), arg)
                )
            )
        )
      )
    end

    rule(:soft_gre_tunnel_group_object) do
      b(arg.as(:arg),
        c(
            b(str("source-address"),
              ipaddr
            ),
            b(str("destination-networks"),
              soft_gre_destination_network_object
            ),
            b(str("service-interface"),
              interface_unit
            ),
            a(str("tunnel-idle-timeout"), arg),
            a(str("dynamic-profile"), arg)
        )
      )
    end

    rule(:soft_gre_destination_network_object) do
      arg.as(:arg)
    end

    rule(:software_datapath_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("ager") | str("commands") | str("configuration") | str("flow") | str("init") | str("ipv6-router-advertisement") | str("memory") | str("redundancy") | str("reassembly") | str("buffering") | str("all"))).as(:oneline)
        )
    end

    rule(:sonet_options_type) do
        c(
            b(str("vtmapping"),
              (str("klm") | str("itu-t"))
            ),
            b(str("fcs"),
              (str("32") | str("16"))
            ),
            a(str("path-trace"), arg),
            b(str("loopback"),
              (str("local") | str("remote"))
            ),
            b(str("trigger"),
                c(
                    b(str("lol"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("pll"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("lof"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("los"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("ais-l"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("rfi-l"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("ber-sd"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ),
                    b(str("ber-sf"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ),
                    b(str("ais-p"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("lop-p"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("rfi-p"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("uneq-p"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("plm-p"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("locd"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("lcdp"),
                        sc(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("aps"),
              aps_type
            ),
            c(
              b(str("payload-scrambler"),
                  sc(
                        arg
                  )
              ).as(:oneline),
              str("no-payload-scrambler")
            ),
            str("z0-increment"),
            str("no-z0-increment"),
            str("loop-timing"),
            str("no-loop-timing"),
            b(str("bytes"),
                c(
                    a(str("e1-quiet"), arg),
                    a(str("f1"), arg),
                    a(str("f2"), arg),
                    a(str("s1"), arg),
                    a(str("z3"), arg),
                    a(str("z4"), arg),
                    a(str("c2"), arg)
                )
            ),
            str("rfc-2615"),
            b(str("aggregate"),
              interface_device
            ),
            b(str("mpls"),
              mpls_ifd_options
            )
        )
    end

    rule(:source_class_name_object) do
      arg.as(:arg).as(:oneline)
    end

    rule(:source_address_filter_list_items) do
        s(
                arg,
          c(
            str("exact"),
            str("longer"),
            str("orlonger"),
            a(str("upto"), arg),
            a(str("through"), arg),
            a(str("prefix-length-range"), arg)
          ),
          c(
            b(str("metric"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg),
                      b(str("igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-igp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("expression"),
                        metric_expression_type
                      ),
                      str("aigp"),
                      b(str("effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline),
                      b(str("minimum-effective-aigp"),
                          sc(
                              arg
                          )
                      ).as(:oneline)
                    )
                )
            ),
            b(str("metric2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric3"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("metric4"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("tag2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("preference2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("color2"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("local-preference"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg)
                    )
                )
            ),
            b(str("priority"),
              (str("high") | str("medium") | str("low"))
            ),
            b(str("prefix-segment"),
                sc(
                    a(str("index"), arg),
                    str("node-segment")
                )
            ).as(:oneline),
            b(str("label-allocation"),
              (str("per-table") | str("per-nexthop") | str("per-table-localize"))
            ),
            b(str("add-path"),
                sc(
                    a(str("send-count"), arg)
                )
            ).as(:oneline),
            b(str("validation-state"),
              (str("valid") | str("invalid") | str("unknown"))
            ),
            b(str("origin"),
              (str("igp") | str("egp") | str("incomplete"))
            ),
            b(str("aigp-originate"),
                sc(
                    a(str("distance"), arg)
                )
            ).as(:oneline),
            b(str("aigp-adjust"),
                sc(
                    c(
                      str("add"),
                      str("subtract"),
                      str("multiply"),
                      str("divide")
                    ),
                    ca(
                      str("distance-to-protocol-nexthop")
                    )
                )
            ).as(:oneline),
            b(str("community"),
                s(
                  c(
                    a(str("="), arg),
                    a(str("set"), arg),
                    a(str("+"), arg),
                    a(str("add"), arg),
                    a(str("-"), arg),
                    a(str("delete"), arg)
                  ),
                        arg
                )
            ).as(:oneline),
            a(str("damping"), arg),
            str("aggregate-bandwidth"),
            a(str("limit-bandwidth"), arg),
            str("no-entropy-label-capability"),
            a(str("as-path-prepend"), quote | arg),
            b(str("as-path-expand"),
                sc(
                    c(
                      b(str("last-as"),
                          sc(
                              a(str("count"), arg)
                          )
                      ).as(:oneline),
                      arg
                    )
                )
            ).as(:oneline),
            b(str("next-hop"),
                sc(
                    c(
                      str("self"),
                      str("peer-address"),
                      str("reject"),
                      str("discard"),
                      a(str("next-table"), arg),
                        ipaddr
                    )
                )
            ).as(:oneline),
            b(str("install-nexthop"),
                sc(
                    c(
                      str("strict"),
                      str("strict-named-lsp")
                    ),
                    c(
                      a(str("lsp"), arg),
                      a(str("lsp-regex"), arg),
                      a(str("static-lsp"), arg),
                      a(str("static-lsp-regex"), arg),
                      str("non-lsp-nexthop"),
                      str("non-labelled-nexthop")
                    ),
                    b(str("except"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("fallback"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    ),
                                    b(str("except"),
                                        c(
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg),
                                              str("non-lsp-nexthop"),
                                              str("non-labelled-nexthop")
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("fallback"),
                        c(
                            c(
                              a(str("lsp"), arg),
                              a(str("lsp-regex"), arg),
                              a(str("static-lsp"), arg),
                              a(str("static-lsp-regex"), arg),
                              str("non-lsp-nexthop"),
                              str("non-labelled-nexthop")
                            ),
                            b(str("except"),
                                c(
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg),
                                      str("non-lsp-nexthop"),
                                      str("non-labelled-nexthop")
                                    )
                                )
                            )
                        )
                    )
                )
            ).as(:oneline),
            str("trace"),
            b(str("external"),
                c(
                    a(str("type"), arg),
                    str("nssa-only")
                )
            ),
            b(str("load-balance"),
                sc(
                    c(
                      str("per-packet"),
                      str("random"),
                      str("per-prefix"),
                      str("consistent-hash"),
                      str("source-ip-only"),
                      str("destination-ip-only")
                    )
                )
            ).as(:oneline),
            str("no-route-localize"),
            str("install-to-fib"),
            str("no-install-to-fib"),
            str("analyze"),
            a(str("class"), arg),
            a(str("destination-class"), arg),
            a(str("source-class"), arg),
            a(str("forwarding-class"), arg),
            b(str("map-to-interface"),
                sc(
                    c(
                      str("self"),
                        interface_name
                    )
                )
            ).as(:oneline),
            b(str("ssm-source"),
              ipaddr
            ),
            b(str("p2mp-lsp-root"),
                c(
                    b(str("address"),
                      ipv4addr
                    )
                )
            ),
            a(str("cos-next-hop-map"), arg),
            a(str("dynamic-tunnel-attributes"), arg),
            str("selected-mldp-egress"),
            str("mhop-bfd-port"),
            str("no-backup"),
            b(str("default-action"),
              (str("accept") | str("reject"))
            ),
            b(str("next"),
              (str("policy") | str("term"))
            ),
            c(
              str("accept"),
              str("reject")
            ),
            b(str("bgp-output-queue-priority"),
                sc(
                    c(
                      a(str("priority"), arg),
                      str("expedited")
                    )
                )
            ).as(:oneline),
            str("multipath-resolve"),
            a(str("sr-te-template"), arg),
            str("label-allocation-fallback-reject"),
            a(str("resolution-map"), arg)
          )
        )
    end

    rule(:spring_te_template_map) do
      b(arg.as(:arg),
        c(
            c(
              a(str("color"), arg),
              str("color-any")
            )
        )
      )
    end

    rule(:srd_ev_action_object) do
        c(
            c(
              str("acquire-mastership"),
              str("release-mastership"),
              str("release-mastership-force"),
              str("release-mastership-if-standby-clear"),
              str("broadcast-warning")
            ),
            b(str("add-static-route"),
              srd_route_add_object
            ),
            b(str("delete-static-route"),
              srd_route_delete_object
            )
        )
    end

    rule(:srd_events_object) do
      b(arg.as(:arg),
        c(
            b(str("monitor"),
                c(
                    a(str("link-down"), arg),
                    b(str("process"),
                        c(
                            b(str("routing"),
                                c(
                                    str("restart"),
                                    str("abort")
                                )
                            )
                        )
                    ),
                    b(str("peer"),
                        c(
                            c(
                              str("mastership-release"),
                              str("mastership-acquire")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:srd_route_add_object) do
      b(arg.as(:arg),
        c(
            c(
              a(str("next-hop"), arg),
              str("receive")
            ),
            a(str("routing-instance"), arg)
        )
      )
    end

    rule(:srd_route_delete_object) do
      b(arg.as(:arg),
        c(
            a(str("routing-instance"), arg)
        )
      )
    end

    rule(:srd_rs_id_object) do
      b(arg.as(:arg),
        c(
            a(str("redundancy-group"), arg),
            a(str("redundancy-policy"), arg),
            a(str("keepalive"), arg),
            a(str("hold-time"), arg),
            a(str("healthcheck-timer-interval"), arg)
        )
      )
    end

    rule(:srd_traceoptions_object) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("config") | str("connect") | str("route") | str("ssd") | str("snmp") | str("system") | str("opcmd") | str("state-machine") | str("kcom") | str("database") | str("swithover") | str("stateful-sync") | str("redundancy-group") | str("all"))).as(:oneline)
        )
    end

    rule(:ssd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("infrastructure") | str("server") | str("routing-instance") | str("client-management") | str("interfaces-management") | str("route-management") | str("nexthop-management") | str("firewall-management") | str("nexthop-group-management") | str("cli") | str("cfg") | str("all"))).as(:oneline)
        )
    end

    rule(:ssl_initiation_config) do
        c(
            b(a(str("profile"), arg),
                c(
                    str("enable-flow-tracing"),
                    b(str("protocol-version"),
                      (str("all") | str("ssl3") | str("tls11") | str("tls12") | str("tls1"))
                    ),
                    b(str("preferred-ciphers"),
                      (str("strong") | str("medium") | str("weak") | str("custom"))
                    ),
                    b(str("custom-ciphers"),
                      (str("rsa-with-rc4-128-md5") | str("rsa-with-rc4-128-sha") | str("rsa-with-des-cbc-sha") | str("rsa-with-3des-ede-cbc-sha") | str("rsa-with-aes-128-cbc-sha") | str("rsa-with-aes-256-cbc-sha") | str("rsa-export-with-rc4-40-md5") | str("rsa-export-with-des40-cbc-sha") | str("rsa-export1024-with-des-cbc-sha") | str("rsa-export1024-with-rc4-56-md5") | str("rsa-export1024-with-rc4-56-sha") | str("rsa-with-aes-256-gcm-sha384") | str("rsa-with-aes-256-cbc-sha256") | str("rsa-with-aes-128-gcm-sha256") | str("rsa-with-aes-128-cbc-sha256") | str("ecdhe-rsa-with-aes-256-gcm-sha384") | str("ecdhe-rsa-with-aes-256-cbc-sha") | str("ecdhe-rsa-with-aes-256-cbc-sha384") | str("ecdhe-rsa-with-3des-ede-cbc-sha") | str("ecdhe-rsa-with-aes-128-gcm-sha256") | str("ecdhe-rsa-with-aes-128-cbc-sha") | str("ecdhe-rsa-with-aes-128-cbc-sha256") | str("ecdhe-ecdsa-with-aes-256-gcm-sha384") | str("ecdhe-ecdsa-with-aes-256-cbc-sha") | str("ecdhe-ecdsa-with-aes-256-cbc-sha384") | str("ecdhe-ecdsa-with-aes-128-gcm-sha256") | str("ecdhe-ecdsa-with-aes-128-cbc-sha") | str("ecdhe-ecdsa-with-aes-128-cbc-sha256") | str("ecdhe-ecdsa-with-3des-ede-cbc-sha"))
                    ),
                    str("enable-session-cache"),
                    b(str("trusted-ca"),
                          (str("all") | arg)
                    ),
                    a(str("client-certificate"), arg),
                    b(str("actions"),
                        c(
                            str("ignore-server-auth-failure"),
                            b(str("crl"),
                                c(
                                    str("disable"),
                                    b(str("if-not-present"),
                                      (str("allow") | str("drop"))
                                    ),
                                    str("ignore-hold-instruction-code")
                                )
                            ),
                            b(str("unsupported-cipher-on-hw"),
                              (str("drop") | str("software-inspection"))
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:ssl_proxy_config) do
        c(
            b(str("global-config"),
                c(
                    a(str("session-cache-timeout"), arg),
                    str("disable-cert-cache"),
                    a(str("certificate-cache-timeout"), arg),
                    str("invalidate-cache-on-crl-update"),
                    a(str("cache-usage-enforcement-threshold"), arg)
                )
            ),
            b(a(str("profile"), arg),
                c(
                    str("enable-flow-tracing"),
                    b(str("protocol-version"),
                      (str("all") | str("ssl3") | str("tls11") | str("tls12") | str("tls1"))
                    ),
                    b(str("preferred-ciphers"),
                      (str("strong") | str("medium") | str("weak") | str("custom"))
                    ),
                    b(str("custom-ciphers"),
                      (str("rsa-with-rc4-128-md5") | str("rsa-with-rc4-128-sha") | str("rsa-with-des-cbc-sha") | str("rsa-with-3des-ede-cbc-sha") | str("rsa-with-aes-128-cbc-sha") | str("rsa-with-aes-256-cbc-sha") | str("rsa-export-with-rc4-40-md5") | str("rsa-export-with-des40-cbc-sha") | str("rsa-export1024-with-des-cbc-sha") | str("rsa-export1024-with-rc4-56-md5") | str("rsa-export1024-with-rc4-56-sha") | str("rsa-with-aes-256-gcm-sha384") | str("rsa-with-aes-256-cbc-sha256") | str("rsa-with-aes-128-gcm-sha256") | str("rsa-with-aes-128-cbc-sha256") | str("ecdhe-rsa-with-aes-256-gcm-sha384") | str("ecdhe-rsa-with-aes-256-cbc-sha") | str("ecdhe-rsa-with-aes-256-cbc-sha384") | str("ecdhe-rsa-with-3des-ede-cbc-sha") | str("ecdhe-rsa-with-aes-128-gcm-sha256") | str("ecdhe-rsa-with-aes-128-cbc-sha") | str("ecdhe-rsa-with-aes-128-cbc-sha256") | str("ecdhe-ecdsa-with-aes-256-gcm-sha384") | str("ecdhe-ecdsa-with-aes-256-cbc-sha") | str("ecdhe-ecdsa-with-aes-256-cbc-sha384") | str("ecdhe-ecdsa-with-aes-128-gcm-sha256") | str("ecdhe-ecdsa-with-aes-128-cbc-sha") | str("ecdhe-ecdsa-with-aes-128-cbc-sha256") | str("ecdhe-ecdsa-with-3des-ede-cbc-sha"))
                    ),
                    str("enable-session-cache"),
                    b(str("trusted-ca"),
                          (str("all") | arg)
                    ),
                    c(
                      a(str("root-ca"), arg),
                      a(str("server-certificate"), arg)
                    ),
                    b(str("mirror-decrypt-traffic"),
                        c(
                            b(str("interface"),
                              interface_name
                            ),
                            b(str("destination-mac-address"),
                              mac_addr
                            ),
                            str("only-after-security-policies-enforcement")
                        )
                    ),
                    a(str("whitelist"), arg),
                    a(str("whitelist-url-categories"), arg),
                    b(str("actions"),
                        c(
                            str("ignore-server-auth-failure"),
                            b(str("log"),
                                c(
                                    str("all"),
                                    str("sessions-dropped"),
                                    str("sessions-allowed"),
                                    str("sessions-ignored"),
                                    str("sessions-whitelisted"),
                                    str("errors"),
                                    str("warning"),
                                    str("info")
                                )
                            ),
                            b(str("crl"),
                                c(
                                    str("disable"),
                                    b(str("if-not-present"),
                                      (str("allow") | str("drop"))
                                    ),
                                    str("ignore-hold-instruction-code")
                                )
                            ),
                            b(str("renegotiation"),
                              (str("allow") | str("allow-secure") | str("drop"))
                            ),
                            str("disable-session-resumption"),
                            b(str("unsupported-cipher-on-hw"),
                              (str("drop") | str("software-inspection"))
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:ssl_termination_config) do
        c(
            b(a(str("profile"), arg),
                c(
                    str("enable-flow-tracing"),
                    b(str("protocol-version"),
                      (str("all") | str("ssl3") | str("tls11") | str("tls12") | str("tls1"))
                    ),
                    b(str("preferred-ciphers"),
                      (str("strong") | str("medium") | str("weak") | str("custom"))
                    ),
                    b(str("custom-ciphers"),
                      (str("rsa-with-rc4-128-md5") | str("rsa-with-rc4-128-sha") | str("rsa-with-des-cbc-sha") | str("rsa-with-3des-ede-cbc-sha") | str("rsa-with-aes-128-cbc-sha") | str("rsa-with-aes-256-cbc-sha") | str("rsa-export-with-rc4-40-md5") | str("rsa-export-with-des40-cbc-sha") | str("rsa-export1024-with-des-cbc-sha") | str("rsa-export1024-with-rc4-56-md5") | str("rsa-export1024-with-rc4-56-sha") | str("rsa-with-aes-256-gcm-sha384") | str("rsa-with-aes-256-cbc-sha256") | str("rsa-with-aes-128-gcm-sha256") | str("rsa-with-aes-128-cbc-sha256") | str("ecdhe-rsa-with-aes-256-gcm-sha384") | str("ecdhe-rsa-with-aes-256-cbc-sha") | str("ecdhe-rsa-with-aes-256-cbc-sha384") | str("ecdhe-rsa-with-3des-ede-cbc-sha") | str("ecdhe-rsa-with-aes-128-gcm-sha256") | str("ecdhe-rsa-with-aes-128-cbc-sha") | str("ecdhe-rsa-with-aes-128-cbc-sha256") | str("ecdhe-ecdsa-with-aes-256-gcm-sha384") | str("ecdhe-ecdsa-with-aes-256-cbc-sha") | str("ecdhe-ecdsa-with-aes-256-cbc-sha384") | str("ecdhe-ecdsa-with-aes-128-gcm-sha256") | str("ecdhe-ecdsa-with-aes-128-cbc-sha") | str("ecdhe-ecdsa-with-aes-128-cbc-sha256") | str("ecdhe-ecdsa-with-3des-ede-cbc-sha"))
                    ),
                    str("enable-session-cache"),
                    b(str("trusted-ca"),
                          (str("all") | arg)
                    ),
                    a(str("server-certificate"), arg)
                )
            )
        )
    end

    rule(:ssl_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("brief") | str("detail") | str("extensive") | str("verbose"))
            ),
            a(str("flag"), enum(str("cli-configuration") | str("termination") | str("initiation") | str("proxy") | str("selected-profile") | str("all"))).as(:oneline),
            b(str("packet-filter"),
                c(
                    b(str("source-ip"),
                      ipaddr
                    ),
                    b(str("destination-ip"),
                      ipaddr
                    ),
                    a(str("source-port"), arg),
                    a(str("destination-port"), arg)
                )
            )
        )
    end

    rule(:stp_interface) do
      b((str("all") | arg).as(:arg),
        c(
            a(str("priority"), arg),
            a(str("cost"), arg),
            b(str("mode"),
              (str("point-to-point") | str("shared"))
            ),
            str("edge"),
            str("access-trunk"),
            b(str("bpdu-timeout-action"),
                c(
                    str("block"),
                    str("alarm")
                )
            ),
            str("no-root-port"),
            str("disable")
        )
      )
    end

    rule(:stp_trace_options) do
        c(
            b(str("file"),
                sc(
                      arg,
                    str("replace"),
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("no-stamp"),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            a(str("flag"), enum(str("events") | str("bpdu") | str("timers") | str("port-information-state-machine") | str("port-receive-state-machine") | str("port-role-select-state-machine") | str("port-role-transit-state-machine") | str("port-state-transit-state-machine") | str("port-migration-state-machine") | str("port-transmit-state-machine") | str("topology-change-state-machine") | str("bridge-detection-state-machine") | str("state-machine-variables") | str("ppmd") | str("all-failures") | str("all")),
                sc(
                    str("disable")
                )
            ).as(:oneline)
        )
    end

    rule(:subscription_type) do
        ca(
            a(str("ct0"), arg),
            a(str("ct1"), arg),
            a(str("ct2"), arg),
            a(str("ct3"), arg)
        )
    end

    rule(:svc_ike_policy) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("mode"),
              (str("main") | str("aggressive"))
            ),
            b(str("version"),
              (str("1") | str("2"))
            ),
            a(str("proposals"), arg),
            b(str("local-id"),
                sc(
                    c(
                      b(str("ipv4_addr"),
                        ipv4addr
                      ),
                      str("distinguished-name"),
                      a(str("fqdn"), arg),
                      a(str("key-id"), arg),
                      b(str("ipv6-addr"),
                        ipv6addr
                      )
                    )
                )
            ).as(:oneline),
            a(str("certificate-policy-oids"), arg),
            a(str("local-certificate"), arg),
            b(str("peer-certificate-type"),
              (str("pkcs7") | str("x509-signature"))
            ),
            b(str("remote-id"),
                c(
                    str("any-remote-id"),
                    b(str("ipv4_addr"),
                      ipv4addr
                    ),
                    b(str("distinguished-name"),
                        c(
                            a(str("container"), arg),
                            a(str("wildcard"), arg),
                            a(str("exact-match"), arg)
                        )
                    ),
                    a(str("fqdn"), arg),
                    a(str("key-id"), arg),
                    b(str("ipv6-addr"),
                      ipv6addr
                    )
                )
            ),
            b(str("pre-shared-key"),
                sc(
                    c(
                      a(str("ascii-text"), arg),
                      a(str("hexadecimal"), arg)
                    )
                )
            ).as(:oneline),
            b(str("respond-bad-spi"),
                sc(
                      arg
                )
            ).as(:oneline)
        )
      )
    end

    rule(:sw_rule_object) do
      b(arg.as(:arg),
        c(
            b(str("match-direction"),
              (str("input") | str("output"))
            ),
            b(a(str("term"), arg),
                c(
                    b(str("then"),
                        c(
                            c(
                              a(str("ds-lite"), arg),
                              a(str("v6rd"), arg),
                              a(str("map-e"), arg)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:syslog_object) do
      b(enum((str("any") | str("authorization") | str("daemon") | str("ftp") | str("ntp") | str("security") | str("kernel") | str("user") | str("dfc") | str("external") | str("firewall") | str("pfe") | str("conflict-log") | str("change-log") | str("interactive-commands"))).as(:arg),
        c(
            c(
              str("any"),
              str("emergency"),
              str("alert"),
              str("critical"),
              str("error"),
              str("warning"),
              str("notice"),
              str("info"),
              str("none")
            )
        )
      ).as(:oneline)
    end

    rule(:system_id_ip_map) do
      b(arg.as(:arg),
        c(
            b(str("ip-address"),
              ipv4prefix
            )
        )
      )
    end

    rule(:tacplus_server_object) do
      b(arg.as(:arg),
        c(
            a(str("routing-instance"), arg),
            a(str("port"), arg),
            b(str("secret"),
              unreadable
            ),
            a(str("timeout"), arg),
            str("single-connection"),
            b(str("source-address"),
              hostname
            )
        )
      )
    end

    rule(:tdir_netmon_object) do
        c(
            b(str("traceoptions"),
              tdir_netmon_traceoptions_object
            ),
            b(str("profile"),
              tdir_netmon_profile_object
            ),
            b(str("source-interface"),
              tdir_netmon_src_iface
            )
        )
    end

    rule(:tdir_netmon_profile_object) do
      b(arg.as(:arg),
        c(
            c(
              b(str("http"),
                tdir_http_probe_object
              ),
              str("icmp"),
              b(str("tcp"),
                tdir_tcp_probe_object
              ),
              b(str("ssl-hello"),
                tdir_ssl_hello_probe_object
              ),
              b(str("custom"),
                tdir_netmon_custom_probe_object
              )
            ),
            a(str("probe-interval"), arg),
            a(str("failure-retries"), arg),
            a(str("recovery-retries"), arg)
        )
      )
    end

    rule(:tdir_http_probe_object) do
        c(
            a(str("port"), arg),
            a(str("url"), arg),
            b(str("method"),
              (str("get") | str("options"))
            ),
            a(str("hostname"), arg)
        )
    end

    rule(:tdir_netmon_custom_probe_object) do
        c(
            b(str("protocol"),
              (str("tcp") | str("udp"))
            ),
            b(str("cmd"),
              tdir_netmon_custom_probe_command_object
            )
        )
    end

    rule(:tdir_netmon_custom_probe_command_object) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            b(str("default-real-service-status"),
              (str("down") | str("up"))
            ),
            b(str("send"),
              tdir_netmon_custom_probe_send_object
            ),
            b(str("expect"),
              tdir_netmon_custom_probe_expect_object
            ).as(:oneline)
        )
      )
    end

    rule(:tdir_netmon_custom_probe_expect_object) do
        c(
            c(
              b(str("ascii"),
                tdir_netmon_cust_probe_ascii_expect_obj
              ).as(:oneline),
              b(str("binary"),
                tdir_netmon_cust_probe_binary_expect_obj
              ).as(:oneline)
            )
        ).as(:oneline)
    end

    rule(:tdir_netmon_cust_probe_ascii_expect_obj) do
        ca(
            b(str("offset"),
              tdir_netmon_cust_probe_expect_offset_obj
            ),
            b(str("real-service-action"),
              (str("up") | str("down"))
            )
        ).as(:oneline)
    end

    rule(:tdir_netmon_cust_probe_binary_expect_obj) do
        ca(
            b(str("offset"),
              tdir_netmon_cust_probe_expect_offset_obj
            ),
            b(str("real-service-action"),
              (str("up") | str("down"))
            )
        ).as(:oneline)
    end

    rule(:tdir_netmon_cust_probe_expect_offset_obj) do
        ca(
            a(str("length"), arg)
        ).as(:oneline)
    end

    rule(:tdir_netmon_custom_probe_send_object) do
        c(
            c(
              a(str("ascii"), arg),
              a(str("binary"), arg)
            )
        ).as(:oneline)
    end

    rule(:tdir_netmon_src_iface) do
      b(arg.as(:arg),
        c(
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            b(str("address"),
                              ipv4addr
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                            b(str("address"),
                              ipv6addr
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:tdir_netmon_traceoptions_object) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable")
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("all-real-services") | str("messages") | str("probe") | str("inter-thread") | str("database") | str("file-descriptor-queue") | str("probe-infra") | str("all"))).as(:oneline),
            b(a(str("monitor"), arg),
                c(
                    a(str("group-name"), arg),
                    a(str("real-services-name"), arg)
                )
            )
        )
    end

    rule(:tdir_service_load_balance_object) do
        c(
            b(str("traceoptions"),
              tdir_traceoptions_object
            ),
            a(str("route-hold-timer"), arg),
            b(str("instance"),
              tdir_slb_instance_object
            )
        )
    end

    rule(:tdir_slb_instance_object) do
      b(arg.as(:arg),
        c(
            b(str("interface"),
              interface_name
            ),
            a(str("server-inet-bypass-filter"), arg),
            a(str("server-inet6-bypass-filter"), arg),
            b(str("client-interface"),
              interface_unit
            ),
            b(str("server-interface"),
              interface_unit
            ),
            a(str("client-vrf"), arg),
            a(str("server-vrf"), arg),
            b(str("group"),
              tdir_slb_group_object
            ),
            b(str("real-service"),
              tdir_real_service_object
            ),
            b(str("virtual-service"),
              tdir_virtual_service_object
            )
        )
      )
    end

    rule(:tdir_real_service_object) do
      b(arg.as(:arg),
        c(
            b(str("address"),
              ipaddr
            ),
            str("admin-down")
        )
      )
    end

    rule(:tdir_slb_group_object) do
      b(arg.as(:arg),
        c(
            a(str("real-services"), arg),
            a(str("routing-instance"), arg),
            a(str("health-check-interface-subunit"), arg),
            a(str("network-monitoring-profile"), arg),
            b(str("real-service-rejoin-options"),
              tdir_auto_rejoin_object
            )
        )
      )
    end

    rule(:tdir_auto_rejoin_object) do
        c(
            str("no-auto-rejoin")
        )
    end

    rule(:tdir_ssl_hello_probe_object) do
        c(
            a(str("port"), arg),
            b(str("version"),
              (str("2") | str("3"))
            )
        )
    end

    rule(:tdir_tcp_probe_object) do
        c(
            a(str("port"), arg)
        )
    end

    rule(:tdir_traceoptions_object) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("normal") | str("config") | str("connect") | str("health") | str("parse") | str("probe") | str("route") | str("snmp") | str("statistics") | str("system") | str("operational-commands") | str("filter") | str("batch") | str("all"))).as(:oneline),
            b(a(str("monitor"), arg),
                c(
                    a(str("virtual-svc-name"), arg),
                    a(str("instance-name"), arg)
                )
            ),
            b(str("in-memory-tracing"),
                sc(
                    a(str("max-lines"), arg)
                )
            ).as(:oneline)
        )
    end

    rule(:tdir_virtual_service_object) do
      b(arg.as(:arg),
        c(
            b(str("mode"),
              (str("layer2-direct-server-return") | str("direct-server-return") | str("translated"))
            ),
            b(str("address"),
              ipaddr
            ),
            a(str("route-metric"), arg),
            a(str("rebalance-threshold"), arg),
            a(str("routing-instance"), arg),
            b(str("service"),
              tdir_virtual_service_svc_object
            ),
            b(str("server-interface"),
              interface_unit
            ),
            a(str("group"), arg),
            b(str("load-balance-method"),
                c(
                    c(
                      b(str("hash"),
                          c(
                              b(str("hash-key"),
                                tdir_virtual_service_lb_hash_method_obj
                              )
                          )
                      ),
                      str("random")
                    )
                )
            )
        )
      )
    end

    rule(:tdir_virtual_service_lb_hash_method_obj) do
        c(
            str("source-ip"),
            str("destination-ip"),
            str("protocol")
        )
    end

    rule(:tdir_virtual_service_svc_object) do
      b(arg.as(:arg),
        c(
            a(str("virtual-port"), arg),
            a(str("server-listening-port"), arg),
            a(str("protocol"), arg),
            str("include-real-server-ips-in-server-filter")
        )
      )
    end

    rule(:te_class_object) do
        c(
            b(str("traffic-class"),
              (str("ct0") | str("ct1") | str("ct2") | str("ct3"))
            ),
            a(str("priority"), arg)
        ).as(:oneline)
    end

    rule(:tenant_system_type) do
      b(arg.as(:arg),
        c(
            a(str("max-sessions"), arg)
        )
      )
    end

    rule(:tenant_interfaces_type) do
      b(arg.as(:arg),
        c(
            a(str("unit"), enum(arg | arg | arg),
                c(
                    b(str("policer-overhead"),
                        ca(
                            a(str("ingress"), arg),
                            a(str("egress"), arg)
                        )
                    ),
                    a(str("alias"), arg),
                    str("enhanced-convergence"),
                    str("proxy-macip-advertisement"),
                    str("virtual-gateway-accept-data"),
                    b(str("peer-psd"),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(str("peer-interface"),
                        c(
                              interface_unit
                        )
                    ),
                    b(str("interface-shared-with"),
                        c(
                            arg
                        )
                    ),
                      (str("disable")),
                    str("passive-monitor-mode"),
                    str("per-session-scheduler"),
                    b(str("account-layer2-overhead"),
                        ca(
                            a(str("ingress"), arg),
                            a(str("egress"), arg)
                        )
                    ),
                    b(str("forwarding-class-accounting"),
                        c(
                            b(str("direction"),
                              (str("ingress") | str("egress") | str("both"))
                            ),
                            b(str("enhanced"),
                                c(
                                    b(str("traffic-type"),
                                      (str("unicast-statistics") | str("multicast-statistics"))
                                    ),
                                    b(str("family"),
                                      (str("inet6") | str("inet") | str("both"))
                                    ),
                                    b(str("direction"),
                                      (str("ingress") | str("egress") | str("both"))
                                    ),
                                    a(str("overhead-bytes"), arg)
                                )
                            )
                        )
                    ),
                    str("clear-dont-fragment-bit"),
                    str("packet-inject-enable"),
                    str("reassemble-packets"),
                    str("services-options"),
                    b(str("rpm"),
                        c(
                            c(
                              c(
                                str("client"),
                                str("server"),
                                str("client-delegate-probes")
                              ),
                              str("twamp-server"),
                              str("twamp-client")
                            )
                        )
                    ),
                    a(str("description"), quote | arg),
                    a(str("metadata"), arg),
                    b(str("dial-options"),
                        c(
                            c(
                              a(str("l2tp-interface-id"), arg),
                              a(str("ipsec-interface-id"), arg)
                            ),
                            c(
                              str("dedicated"),
                              str("shared")
                            )
                        )
                    ),
                    str("actual-transit-statistics"),
                    b(str("demux-source"),
                          enum((str("inet6") | str("inet")))
                    ),
                    b(str("demux-destination"),
                          enum((str("inet6") | str("inet")))
                    ),
                    b(str("demux"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("address"),
                                      (str("source") | str("destination"))
                                    ),
                                    b(str("auto-configure"),
                                      dynamic_ipv4_type
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("address"),
                                      (str("source") | str("destination"))
                                    ),
                                    b(str("auto-configure"),
                                      dynamic_ipv6_type
                                    )
                                )
                            )
                        )
                    ),
                    b(str("encapsulation"),
                      (str("atm-nlpid") | str("atm-cisco-nlpid") | str("atm-snap") | str("atm-vc-mux") | str("atm-ccc-vc-mux") | str("atm-tcc-vc-mux") | str("atm-tcc-snap") | str("atm-ccc-cell-relay") | str("vlan-vci-ccc") | str("ether-over-atm-llc") | str("ether-vpls-over-atm-llc") | str("ppp-over-ether-over-atm-llc") | str("ppp-over-ether") | str("atm-ppp-vc-mux") | str("atm-ppp-llc") | str("atm-mlppp-llc") | str("frame-relay-ppp") | str("frame-relay-ccc") | str("frame-relay") | str("frame-relay-tcc") | str("frame-relay-ether-type") | str("frame-relay-ether-type-tcc") | str("ether-vpls-fr") | str("vlan-ccc") | str("ethernet-ccc") | str("vlan-vpls") | str("vlan-bridge") | str("dix") | str("ethernet-vpls") | str("ethernet-bridge") | str("ethernet") | str("vlan") | str("vlan-tcc") | str("multilink-ppp") | str("multilink-frame-relay-end-to-end") | str("ppp-ccc"))
                    ),
                    str("gre"),
                    a(str("mtu"), arg),
                    c(
                      str("point-to-point"),
                      str("multipoint")
                    ),
                    a(str("bandwidth"), arg),
                    a(str("global-layer2-domainid"), arg),
                    b(str("radio-router"),
                      dynamic_ifbw_parms_type
                    ),
                    str("traps"),
                    str("no-traps"),
                    str("routing-services"),
                    str("no-routing-services"),
                    b(str("routing-service"),
                        c(
                              (str("enable") | str("disable"))
                        )
                    ),
                    b(str("arp-resp"),
                        sc(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    b(str("proxy-arp"),
                        sc(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    c(
                      b(str("vlan-id"),
                        (str("none") | arg)
                      ),
                      a(str("vlan-id-range"), arg),
                      a(str("inner-vlan-id-swap-ranges"), arg),
                      a(str("vlan-id-list"), arg),
                      a(str("vlan-tag"), arg),
                      b(str("vlan-tags"),
                          sc(
                              b(str("outer"),
                                (arg | arg | arg)
                              ),
                              c(
                                b(str("inner"),
                                  (arg | arg)
                                ),
                                a(str("inner-range"), arg),
                                a(str("inner-list"), arg)
                              )
                          )
                      ).as(:oneline)
                    ),
                    a(str("deep-vlan-qualified-learning"), arg),
                    a(str("native-inner-vlan-id"), arg),
                    b(str("inner-vlan-id-range"),
                        sc(
                            a(str("start"), arg),
                            a(str("end"), arg)
                        )
                    ).as(:oneline),
                    b(str("accept-source-mac"),
                        c(
                            b(str("mac-address"),
                              mac_list
                            )
                        )
                    ),
                    b(str("input-vlan-map"),
                      vlan_map
                    ),
                    b(str("output-vlan-map"),
                      vlan_map
                    ),
                    str("swap-by-poppush"),
                    a(str("receive-lsp"), arg),
                    a(str("transmit-lsp"), arg),
                    a(str("dlci"), arg),
                    a(str("multicast-dlci"), arg),
                    c(
                      b(str("vci"),
                        atm_vci
                      ),
                      str("allow-any-vci"),
                      a(str("vpi"), arg),
                      a(str("trunk-id"), arg)
                    ),
                    str("no-vpivci-swapping"),
                    c(
                      b(str("psn-vci"),
                        atm_vci
                      ),
                      a(str("psn-vpi"), arg)
                    ),
                    b(str("atm-l2circuit-mode"),
                        sc(
                            c(
                              str("cell"),
                              str("aal5")
                            )
                        )
                    ).as(:oneline),
                    b(str("vci-range"),
                        sc(
                            a(str("start"), arg),
                            a(str("end"), arg)
                        )
                    ).as(:oneline),
                    a(str("trunk-bandwidth"), arg),
                    b(str("multicast-vci"),
                      atm_vci
                    ),
                    b(str("shaping"),
                      dcd_shaping_config
                    ),
                    b(str("oam-period"),
                        sc(
                            ca(
                              str("disable").as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oam-liveness"),
                        c(
                            a(str("up-count"), arg),
                            a(str("down-count"), arg)
                        )
                    ),
                    b(str("ppp-options"),
                      ppp_options_type
                    ),
                    b(str("pppoe-options"),
                      pppoe_options_type
                    ),
                    b(str("pppoe-underlying-options"),
                      pppoe_underlying_options_type
                    ),
                    b(str("advisory-options"),
                      advisory_options_type
                    ),
                    b(str("auto-configure"),
                      auto_configure_vlan_type
                    ),
                    b(str("demux-options"),
                      demux_options_type
                    ),
                    b(str("targeted-distribution"),
                        c(
                            a(str("primary-list"), arg),
                            a(str("backup-list"), arg),
                            a(str("standby-list"), arg)
                        )
                    ),
                    b(str("targeted-options"),
                        c(
                            b(str("weight"),
                              (arg | arg)
                            ),
                            b(str("primary"),
                              interface_device
                            ),
                            b(str("backup"),
                              interface_device
                            ),
                            a(str("group"), arg)
                        )
                    ),
                    c(
                      b(str("keepalives"),
                        keepalives_type
                      ).as(:oneline),
                      str("no-keepalives")
                    ),
                    str("inverse-arp"),
                    a(str("transmit-weight"), arg),
                    b(str("epd-threshold"),
                      epd_threshold_config
                    ).as(:oneline),
                    a(str("cell-bundle-size"), arg),
                    a(str("cell-bundle-timeout"), arg),
                    str("plp-to-clp"),
                    a(str("atm-scheduler-map"), arg),
                    a(str("mrru"), arg),
                    str("short-sequence"),
                    a(str("fragment-threshold"), arg),
                    a(str("drop-timeout"), arg),
                    str("disable-mlppp-inner-ppp-pfc"),
                    a(str("minimum-links"), arg),
                    a(str("multilink-max-classes"), arg),
                    b(str("compression"),
                        c(
                            b(str("rtp"),
                                c(
                                    a(str("f-max-period"), arg),
                                    b(str("queues"),
                                      (str("q0") | str("q1") | str("q2") | str("q3"))
                                    ),
                                    b(str("port"),
                                        sc(
                                            a(str("minimum"), arg),
                                            a(str("maximum"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("maximum-contexts"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    str("interleave-fragments"),
                    b(str("link-layer-overhead"),
                      unsigned_float
                    ),
                    a(str("accounting-profile"), arg),
                    a(str("peer-unit"), arg),
                    b(str("tunnel"),
                        c(
                            b(str("encapsulation"),
                                c(
                                    b(str("vxlan-gpe"),
                                        c(
                                            b(str("source"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    ),
                                                    b(str("interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("tunnel-endpoint"),
                                              (str("vxlan"))
                                            ),
                                            a(str("destination-udp-port"), arg),
                                            a(str("vni"), arg)
                                        )
                                    ),
                                    b(str("udp"),
                                        c(
                                            b(str("source"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    ),
                                                    b(str("interface"),
                                                      interface_name
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("source"),
                              ipaddr
                            ),
                            b(str("destination"),
                              ipaddr
                            ),
                            a(str("key"), arg),
                            b(str("backup-destination"),
                              ipaddr
                            ),
                            c(
                              str("allow-fragmentation"),
                              str("do-not-fragment")
                            ),
                            a(str("ttl"), arg),
                            a(str("traffic-class"), arg),
                            a(str("flow-label"), arg),
                            str("path-mtu-discovery"),
                            str("no-path-mtu-discovery"),
                            b(str("routing-instance"),
                                c(
                                    a(str("destination"), arg)
                                )
                            )
                        )
                    ),
                    b(str("compression-device"),
                      interface_unit
                    ),
                    b(str("atm-policer"),
                        c(
                            a(str("input-atm-policer"), arg)
                        )
                    ),
                    b(str("layer2-policer"),
                        c(
                            c(
                              a(str("input-policer"), arg),
                              a(str("input-hierarchical-policer"), arg),
                              a(str("input-three-color"), arg)
                            ),
                            c(
                              b(str("output-policer"),
                                (arg | arg)
                              ),
                              b(str("output-three-color"),
                                (arg | arg)
                              )
                            )
                        )
                    ),
                    b(str("filter"),
                        c(
                            c(
                              b(str("input"),
                                  sc(
                                      arg,
                                      a(str("shared-name"), arg),
                                      a(str("precedence"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            c(
                              b(str("output"),
                                  sc(
                                      arg,
                                      a(str("shared-name"), arg),
                                      a(str("precedence"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ),
                    b(str("multi-chassis-protection"),
                      multi_chassis_protection_group_ifl
                    ),
                    str("statistics"),
                    b(str("esi"),
                        c(
                            b(str("auto-derive"),
                                c(
                                    c(
                                      str("lacp")
                                    )
                                )
                            ),
                              esi,
                            c(
                              str("single-active"),
                              str("all-active")
                            ),
                            b(str("df-election-type"),
                                c(
                                    c(
                                      b(str("preference"),
                                          c(
                                              a(str("value"), arg)
                                          )
                                      )
                                    ),
                                    c(
                                      str("mod")
                                    )
                                )
                            ),
                            b(str("source-bmac"),
                              mac_unicast
                            )
                        )
                    ),
                    c(
                      str("no-auto-virtual-gateway-esi"),
                      b(str("virtual-gateway-esi"),
                          c(
                                esi,
                              c(
                                str("single-active"),
                                str("all-active")
                              )
                          )
                      )
                    ),
                    b(str("service"),
                        c(
                            b(a(str("pcef"), arg),
                                c(
                                    str("activate-all"),
                                    a(str("activate"), arg)
                                )
                            )
                        )
                    ),
                    str("generate-eui64"),
                    str("no-generate-eui64"),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("dhcp"),
                                      dhcp_client_type
                                    ),
                                    b(str("targeted-broadcast"),
                                        c(
                                            c(
                                              str("forward-and-send-to-re"),
                                              str("forward-only")
                                            )
                                        )
                                    ),
                                    str("destination-class-usage"),
                                    str("transit-options-packets"),
                                    str("transit-ttl-exceeded"),
                                    str("receive-options-packets"),
                                    str("receive-ttl-exceeded"),
                                    b(str("accounting"),
                                        c(
                                            b(str("source-class-usage"),
                                                c(
                                                    str("input"),
                                                    str("output")
                                                )
                                            ),
                                            str("destination-class-usage")
                                        )
                                    ),
                                    b(str("mac-validate"),
                                      (str("strict") | str("loose"))
                                    ),
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                sc(
                                                    str("loose")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    a(str("mtu"), arg),
                                    a(str("arp-max-cache"), arg),
                                    a(str("arp-new-hold-limit"), arg),
                                    a(str("tcp-mss"), arg),
                                    str("no-redirects"),
                                    str("no-neighbor-learn"),
                                    str("unconditional-src-learn"),
                                    str("multicast-only"),
                                    str("primary"),
                                    a(str("ipsec-sa"), arg),
                                    str("allow-filter-on-re"),
                                    a(str("demux-source"), arg | arg),
                                    a(str("demux-destination"), arg | arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("simple-filter"),
                                        c(
                                            a(str("input"), arg)
                                        )
                                    ),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("arp"), arg),
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    ),
                                    b(str("service"),
                                        c(
                                            b(str("input"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    ),
                                                    a(str("post-service-filter"), arg)
                                                )
                                            ),
                                            b(str("output"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("next-hop-tunnel"), arg),
                                        c(
                                            a(str("ipsec-vpn"), arg)
                                        )
                                    ),
                                    b(a(str("address"), arg),
                                        c(
                                            b(str("destination"),
                                              ipv4addr
                                            ),
                                            a(str("destination-profile"), arg),
                                            b(str("broadcast"),
                                              ipv4addr
                                            ),
                                            str("primary"),
                                            str("preferred"),
                                            str("master-only"),
                                            b(a(str("multipoint-destination"), arg),
                                                c(
                                                    c(
                                                      a(str("dlci"), arg),
                                                      b(str("vci"),
                                                        atm_vci
                                                      )
                                                    ),
                                                    b(str("shaping"),
                                                      dcd_shaping_config
                                                    ),
                                                    b(str("oam-period"),
                                                        sc(
                                                            ca(
                                                              str("disable").as(:oneline)
                                                            )
                                                        )
                                                    ).as(:oneline),
                                                    b(str("oam-liveness"),
                                                        c(
                                                            a(str("up-count"), arg),
                                                            a(str("down-count"), arg)
                                                        )
                                                    ),
                                                    str("inverse-arp"),
                                                    a(str("transmit-weight"), arg),
                                                    b(str("epd-threshold"),
                                                      epd_threshold_config
                                                    ).as(:oneline)
                                                )
                                            ),
                                            b(a(str("arp"), arg),
                                                sc(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicast
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(a(str("host-discovery"), arg),
                                                sc(
                                                    a(str("aging-timer"), arg),
                                                    a(str("discovery-interval"), arg)
                                                )
                                            ).as(:oneline),
                                            b(str("web-authentication"),
                                                c(
                                                    str("https"),
                                                    str("http"),
                                                    str("redirect-to-https")
                                                )
                                            ),
                                            b(str("vrrp-group"),
                                              vrrp_group
                                            ),
                                            b(str("virtual-gateway-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("unnumbered-address"),
                                        sc(
                                              interface_unit,
                                            b(str("preferred-source-address"),
                                              (arg | arg)
                                            ),
                                            b(str("destination"),
                                              ipv4addr
                                            ),
                                            a(str("destination-profile"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("location-pool-address"),
                                        c(
                                              arg
                                        )
                                    ),
                                    str("negotiate-address"),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("iso"),
                                c(
                                    a(str("address"), arg),
                                    a(str("mtu"), arg),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("dhcpv6-client"),
                                        c(
                                            b(str("client-type"),
                                              (str("stateful") | str("autoconfig"))
                                            ),
                                            a(str("client-ia-type"), enum(str("ia-na") | str("ia-pd"))),
                                            str("rapid-commit"),
                                            b(str("prefix-delegating"),
                                                c(
                                                    a(str("preferred-prefix-length"), arg),
                                                    a(str("sub-prefix-length"), arg)
                                                )
                                            ),
                                            b(str("client-identifier"),
                                                sc(
                                                    b(str("duid-type"),
                                                      (str("duid-llt") | str("vendor") | str("duid-ll"))
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("req-option"), enum(str("dns-server") | str("domain") | str("ntp-server") | str("time-zone") | str("sip-server") | str("sip-domain") | str("nis-server") | str("nis-domain") | str("fqdn") | str("vendor-spec") | str("zero-touch-redirect"))),
                                            b(str("options"),
                                                c(
                                                    b(a(str("number"), arg),
                                                        sc(
                                                            c(
                                                              a(str("hex-string"), arg)
                                                            )
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("retransmission-attempt"), arg),
                                            str("no-dns-install"),
                                            b(str("update-router-advertisement"),
                                                c(
                                                    b(a(str("interface"), arg),
                                                        c(
                                                            str("managed-configuration"),
                                                            str("no-managed-configuration"),
                                                            str("other-stateful-configuration"),
                                                            str("no-other-stateful-configuration"),
                                                            a(str("max-advertisement-interval"), arg),
                                                            a(str("min-advertisement-interval"), arg),
                                                            str("enable-recursive-dns-server-option"),
                                                            str("no-enable-recursive-dns-server-option")
                                                        )
                                                    )
                                                )
                                            ),
                                            str("update-server")
                                        )
                                    ),
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                sc(
                                                    str("loose")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("accounting"),
                                        c(
                                            b(str("source-class-usage"),
                                                c(
                                                    str("input"),
                                                    str("output")
                                                )
                                            ),
                                            str("destination-class-usage")
                                        )
                                    ),
                                    a(str("mtu"), arg),
                                    a(str("tcp-mss"), arg),
                                    a(str("nd6-stale-time"), arg),
                                    str("no-neighbor-learn"),
                                    str("slaac-enable"),
                                    b(str("ndp-proxy"),
                                        c(
                                            str("interface-restricted")
                                        )
                                    ),
                                    b(str("dad-proxy"),
                                        c(
                                            str("interface-restricted")
                                        )
                                    ),
                                    a(str("nd6-max-cache"), arg),
                                    a(str("nd6-new-hold-limit"), arg),
                                    str("no-redirects"),
                                    str("allow-filter-on-re"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    ),
                                    b(str("service"),
                                        c(
                                            b(str("input"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    ),
                                                    a(str("post-service-filter"), arg)
                                                )
                                            ),
                                            b(str("output"),
                                                c(
                                                    b(a(str("service-set"), arg),
                                                        c(
                                                            a(str("service-filter"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("address"), arg),
                                        c(
                                            b(str("destination"),
                                              ipv6addr
                                            ),
                                            str("eui-64"),
                                            str("primary"),
                                            str("preferred"),
                                            str("master-only"),
                                            b(a(str("ndp"), arg),
                                                sc(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicast
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(str("vrrp-inet6-group"),
                                              vrrp_group
                                            ),
                                            b(str("web-authentication"),
                                                c(
                                                    str("https"),
                                                    str("http"),
                                                    str("redirect-to-https")
                                                )
                                            ),
                                            b(str("virtual-gateway-address"),
                                              ipv6addr
                                            ),
                                            str("subnet-router-anycast")
                                        )
                                    ),
                                    a(str("demux-source"), arg | arg | arg),
                                    a(str("demux-destination"), arg | arg),
                                    b(str("unnumbered-address"),
                                        sc(
                                              interface_unit,
                                            b(str("preferred-source-address"),
                                              (arg | arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    str("dad-disable"),
                                    str("no-dad-disable"),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    a(str("mtu"), arg),
                                    a(str("maximum-labels"), arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              a(str("input"), arg),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("output-chain"), arg),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    a(str("destination-udp-port"), arg)
                                )
                            ),
                            b(str("mlppp"),
                                c(
                                    b(str("bundle"),
                                      (arg | arg)
                                    ),
                                    c(
                                      b(str("service-interface"),
                                        interface_device
                                      ),
                                      a(str("service-device-pool"), arg)
                                    ),
                                    a(str("dynamic-profile"), arg)
                                )
                            ),
                            b(str("mlfr-end-to-end"),
                                c(
                                    b(str("bundle"),
                                      interface_unit
                                    )
                                )
                            ),
                            b(str("mlfr-uni-nni"),
                                c(
                                    b(str("bundle"),
                                      interface_unit
                                    )
                                )
                            ),
                            b(str("ccc"),
                                c(
                                    a(str("mtu"), arg),
                                    b(str("filter"),
                                        c(
                                            c(
                                              a(str("input"), arg),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("output-chain"), arg),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    str("translate-fecn-and-becn"),
                                    c(
                                      str("translate-discard-eligible"),
                                      str("translate-plp-control-word-de")
                                    ),
                                    str("keep-address-and-control")
                                )
                            ),
                            b(str("tcc"),
                                c(
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("proxy"),
                                        c(
                                            b(str("inet-address"),
                                              ipv4addr
                                            )
                                        )
                                    ),
                                    b(str("remote"),
                                        c(
                                            b(str("inet-address"),
                                              ipv4addr
                                            ),
                                            b(str("mac-address"),
                                              mac_addr
                                            )
                                        )
                                    ),
                                    b(str("protocols"),
                                      (str("mpls") | str("inet") | str("iso"))
                                    )
                                )
                            ),
                            b(str("vpls"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            a(str("input-chain"), arg),
                                            a(str("output-chain"), arg),
                                            c(
                                              b(str("output"),
                                                  sc(
                                                      arg,
                                                      a(str("shared-name"), arg),
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("output-list"), arg)
                                            ),
                                            b(str("adf"),
                                                c(
                                                    a(str("rule"), arg),
                                                    str("counter"),
                                                    a(str("input-precedence"), arg),
                                                    str("not-mandatory"),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("ingress-queuing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("iq-policing-filter"),
                                        sc(
                                            arg
                                        )
                                    ).as(:oneline),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    b(str("interface-mode"),
                                      (str("access") | str("trunk"))
                                    ),
                                    str("vlan-auto-sense"),
                                    b(str("bridge-domain-type"),
                                      (str("svlan") | str("bvlan"))
                                    ),
                                    str("inter-switch-link"),
                                    c(
                                      a(str("vlan-id"), arg),
                                      a(str("vlan-id-list"), arg),
                                      a(str("inner-vlan-id-list"), arg)
                                    ),
                                    b(str("vlan-rewrite"),
                                        c(
                                            b(a(str("translate"), arg),
                                                sc(
                                                      arg
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    c(
                                      b(str("isid-list"),
                                        (str("all-service-groups") | str("all"))
                                      )
                                    ),
                                    b(str("storm-control"),
                                        c(
                                            arg
                                        )
                                    ),
                                    b(str("recovery-timeout"),
                                        sc(
                                              arg
                                        )
                                    ).as(:oneline),
                                    b(str("sampling"),
                                        c(
                                            str("input"),
                                            str("output")
                                        )
                                    )
                                )
                            ),
                            b(str("ethernet-switching"),
                              ethernet_switching_type
                            ),
                            b(str("fibre-channel"),
                              fibre_channel_type
                            ),
                            b(str("pppoe"),
                              pppoe_underlying_options_type
                            ),
                            b(str("any"),
                                c(
                                    b(str("filter"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("group"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("service-domain"),
                      (str("inside") | str("outside"))
                    ),
                    str("copy-tos-to-outer-ip-header"),
                    str("copy-tos-to-outer-ip-header-transit"),
                    str("force-control-packets-on-transit-path"),
                    b(str("load-balancing-options"),
                        c(
                            b(str("preferred-active"),
                              interface_device
                            ),
                            str("disable-hash"),
                            b(str("hash-keys"),
                                c(
                                    b(str("ingress-key"),
                                          enum((str("source-ip") | str("destination-ip") | str("protocol") | str("iif")))
                                    ),
                                    b(str("egress-key"),
                                          enum((str("source-ip") | str("destination-ip") | str("protocol") | str("oif")))
                                    ),
                                    b(str("ipv6-source-prefix-length"),
                                      (str("56") | str("64") | str("96") | str("128"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("mac"),
                      mac_unicast
                    ),
                    b(str("virtual-gateway-v4-mac"),
                      mac_unicast
                    ),
                    b(str("virtual-gateway-v6-mac"),
                      mac_unicast
                    ),
                    b(str("forwarding-options"),
                        c(
                            b(str("load-balance-stateful"),
                                c(
                                    str("per-flow"),
                                    a(str("rebalance"), arg),
                                    b(str("load-type"),
                                      (str("high") | str("medium") | str("low"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("etree-ac-role"),
                      (str("root") | str("leaf"))
                    )
                )
            )
        )
      )
    end

    rule(:three_color_policer_type) do
      b(arg.as(:arg),
        c(
            str("filter-specific"),
            str("logical-interface-policer"),
            str("physical-interface-policer"),
            str("shared-bandwidth-policer"),
            b(str("action"),
                c(
                    b(str("loss-priority"),
                      three_color_policer_action
                    ).as(:oneline)
                )
            ),
            c(
              b(str("single-rate"),
                  c(
                      c(
                        str("color-blind"),
                        str("color-aware")
                      ),
                      a(str("committed-information-rate"), arg),
                      a(str("committed-burst-size"), arg),
                      a(str("excess-burst-size"), arg)
                  )
              ),
              b(str("single-packet-rate"),
                  c(
                      c(
                        str("color-blind"),
                        str("color-aware")
                      ),
                      a(str("committed-information-pps"), arg),
                      a(str("committed-packet-burst"), arg),
                      a(str("excess-packet-burst"), arg)
                  )
              ),
              b(str("two-rate"),
                  c(
                      c(
                        str("color-blind"),
                        str("color-aware")
                      ),
                      a(str("committed-information-rate"), arg),
                      a(str("committed-burst-size"), arg),
                      a(str("peak-information-rate"), arg),
                      a(str("peak-burst-size"), arg),
                      b(str("aggregate-policing"),
                          c(
                              b(a(str("policer"), arg),
                                  c(
                                      b(str("aggregate-sharing-mode"),
                                        (str("hybrid"))
                                      )
                                  )
                              )
                          )
                      )
                  )
              ),
              b(str("two-packet-rate"),
                  c(
                      c(
                        str("color-blind"),
                        str("color-aware")
                      ),
                      a(str("committed-information-pps"), arg),
                      a(str("committed-packet-burst"), arg),
                      a(str("peak-information-pps"), arg),
                      a(str("peak-packet-burst"), arg)
                  )
              )
            )
        )
      )
    end

    rule(:three_color_policer_action) do
      b((str("high")).as(:arg),
        c(
            b(str("then"),
                c(
                    str("discard")
                )
            )
        )
      ).as(:oneline)
    end

    rule(:to_fabric_object) do
        c(
            str("except")
        )
    end

    rule(:transaction_method_type) do
      enum((str("method-invite") | str("method-options") | str("method-refer") | str("method-subscribe") | str("method-publish") | str("method-message") | str("method-register"))).as(:arg)
    end

    rule(:transaction_policy_type) do
      b(arg.as(:arg),
        c(
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      new_transaction_from_type
                    ),
                    b(str("then"),
                      new_transaction_then_type
                    )
                )
            )
        )
      )
    end

    rule(:new_transaction_then_type) do
        c(
            str("accept"),
            str("reject"),
            b(str("route"),
              route_action
            ),
            str("trace"),
            a(str("admission-control"), arg),
            b(str("message-manipulation"),
                c(
                    a(str("forward-manipulation"), arg),
                    a(str("reverse-manipulation"), arg)
                )
            ),
            a(str("signaling-realm"), arg),
            b(str("on-3xx-response"),
                c(
                    c(
                      a(str("recursion-limit"), arg)
                    )
                )
            )
        )
    end

    rule(:route_action) do
        c(
            b(str("next-hop"),
                c(
                    c(
                      b(str("address"),
                        routing_destination_address
                      ),
                      str("request-uri"),
                      str("sip-based")
                    )
                )
            ),
            a(str("egress-service-point"), arg),
            a(str("server-cluster"), arg)
        )
    end

    rule(:transport_protocol) do
        c(
            c(
              str("udp"),
              str("tcp")
            )
        )
    end

    rule(:tty_port_object) do
        c(
            b(str("authentication-order"),
              (str("radius") | str("tacplus") | str("password"))
            ),
            str("log-out-on-disconnect"),
            b(str("port-type"),
              (str("rj45") | str("mini-usb"))
            ),
            str("disable"),
            str("insecure"),
            b(str("speed"),
              (str("1200") | str("2400") | str("4800") | str("9600") | str("19200") | str("38400") | str("57600") | str("115200"))
            ),
            b(str("type"),
              (str("ansi") | str("vt100") | str("small-xterm") | str("xterm"))
            ),
            str("silent-with-modem")
        )
    end

    rule(:tunable_object) do
      b(arg.as(:arg),
        c(
            a(str("tunable-value"), arg)
        )
      )
    end

    rule(:tunnel_end_point) do
      b(arg.as(:arg),
        c(
            c(
              b(str("ipv6"),
                  c(
                      b(str("source-address"),
                        ipv6addr
                      ),
                      b(str("destination-address"),
                        ipv6prefix
                      )
                  )
              ),
              b(str("ipv4"),
                  c(
                      b(str("source-address"),
                        ipv4addr
                      ),
                      b(str("destination-address"),
                        ipv4prefix
                      )
                  )
              )
            ),
            c(
              b(str("gre"),
                  c(
                      a(str("key"), arg)
                  )
              ),
              b(str("gre-in-udp"),
                  c(
                      a(str("source-port"), arg),
                      a(str("destination-port"), arg),
                      a(str("key"), arg)
                  )
              )
            )
        )
      )
    end

    rule(:tunnel_interface_type) do
      arg.as(:arg)
    end

    rule(:twamp_authentication_key_chain) do
      b(arg.as(:arg),
        c(
            b(a(str("key-id"), arg),
                c(
                    a(str("secret"), arg)
                )
            )
        )
      )
    end

    rule(:unified_edge_gateway_diameter) do
        c(
            b(a(str("network-element"), arg),
                c(
                    b(str("session-pics"),
                      unified_edge_gateway_diameter_ne_session_pics
                    )
                )
            )
        )
    end

    rule(:unified_edge_gateway_diameter_ne_session_pics) do
        c(
            b(a(str("group"), arg),
                c(
                    a(str("session-pic"), arg)
                )
            )
        )
    end

    rule(:unified_edge_ggsn_pgw_system) do
        c(
            b(str("pfes"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("service-mode"),
                              (str("maintenance"))
                            )
                        )
                    )
                )
            ),
            b(str("session-pics"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("service-mode"),
                              (str("maintenance"))
                            )
                        )
                    )
                )
            ),
            b(str("service-pics"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("service-mode"),
                              (str("maintenance"))
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:unified_edge_mobile_options) do
        c(
            b(str("traceoptions"),
              mobiled_traceoptions
            )
        )
    end

    rule(:mobiled_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("flag"), enum(str("configuration") | str("protocol") | str("init") | str("error") | str("all")),
                sc(
                    str("send"),
                    str("receive"),
                    str("detail"),
                    str("disable")
                )
            ).as(:oneline)
        )
    end

    rule(:unified_edge_pcef) do
        c(
            b(str("traceoptions"),
              pcef_traceoptions
            ),
            b(str("event-trigger-profiles"),
                c(
                      evt_trigger_profile
                )
            ),
            b(str("flow-descriptions"),
                c(
                      pcc_flow
                )
            ),
            b(str("pcc-action-profiles"),
                c(
                      pcc_action_profile
                )
            ),
            b(str("pcc-rules"),
                c(
                      pcc_rule
                )
            ),
            b(str("pcc-rulebases"),
                c(
                      pcc_rulebase
                )
            ),
            b(str("profiles"),
                c(
                      pcef_profiles
                )
            ),
            b(str("pcc-time-of-day-profiles"),
                c(
                      pcef_time_of_day_profile
                )
            )
        )
    end

    rule(:pcef_time_of_day_profile) do
      b(arg.as(:arg),
        c(
            b(str("rule-activation-time"),
              pcef_tod_time_type
            ),
            b(str("rule-deactivation-time"),
              pcef_tod_time_type
            )
        )
      )
    end

    rule(:pcef_tod_time_type) do
        c(
            c(
              str("SUNDAY"),
              str("MONDAY"),
              str("TUESDAY"),
              str("WEDNESDAY"),
              str("THURSDAY"),
              str("FRIDAY"),
              str("SATURDAY"),
              str("DAY1"),
              str("DAY2"),
              str("DAY3"),
              str("DAY4"),
              str("DAY5"),
              str("DAY6"),
              str("DAY7"),
              str("DAY8"),
              str("DAY9"),
              str("DAY10"),
              str("DAY11"),
              str("DAY12"),
              str("DAY13"),
              str("DAY14"),
              str("DAY15"),
              str("DAY16"),
              str("DAY17"),
              str("DAY18"),
              str("DAY19"),
              str("DAY20"),
              str("DAY21"),
              str("DAY22"),
              str("DAY23"),
              str("DAY24"),
              str("DAY25"),
              str("DAY26"),
              str("DAY27"),
              str("Last-day-of-month")
            ),
            c(
              str("JANUARY"),
              str("FEBRUARY"),
              str("MARCH"),
              str("APRIL"),
              str("MAY"),
              str("JUNE"),
              str("JULY"),
              str("AUGUST"),
              str("SEPTEMBER"),
              str("OCTOBER"),
              str("NOVEMBER"),
              str("DECEMBER")
            ),
              date
        )
    end

    rule(:unified_edge_sgw_system) do
        c(
            b(str("pfes"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("service-mode"),
                              (str("maintenance"))
                            )
                        )
                    )
                )
            ),
            b(str("session-pics"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("service-mode"),
                              (str("maintenance"))
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:unified_edge_tdf) do
      b(arg.as(:arg),
        c(
            b(str("service-mode"),
              (str("maintenance"))
            ),
            b(str("system"),
              unified_edge_tdf_system
            ),
            b(str("call-rate-statistics"),
                c(
                    a(str("interval"), arg),
                    a(str("history"), arg)
                )
            ),
            b(str("traceoptions"),
              mobile_smd_traceoptions
            ),
            b(str("cac"),
                c(
                    a(str("maximum-subscribers"), arg),
                    a(str("maximum-subscribers-trap-percentage"), arg),
                    b(str("memory"),
                        c(
                            a(str("percentage"), arg)
                        )
                    ),
                    b(str("cpu"),
                        c(
                            a(str("percentage"), arg)
                        )
                    )
                )
            ),
            b(str("charging"),
                c(
                    b(str("traceoptions"),
                      charging_traceoptions
                    ),
                    b(str("charging-profiles"),
                        c(
                              juniper_charging_profiles
                        )
                    ),
                    b(str("transport-profiles"),
                        c(
                              juniper_transport_profiles
                        )
                    )
                )
            ),
            b(str("domains"),
                c(
                      tdf_domain
                )
            ),
            b(str("domain-selection"),
                c(
                    b(a(str("term"), arg),
                        c(
                            b(str("from"),
                              domain_sel_match_object
                            ),
                            b(str("then"),
                                c(
                                    a(str("domain"), arg),
                                    a(str("pcef-profile"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("aaa"),
                c(
                    b(str("clients"),
                        c(
                            arg
                        )
                    ),
                    b(str("snoop-segments"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:domain_sel_match_object) do
        c(
            a(str("client"), arg),
            a(str("snoop-segment"), arg),
            b(str("user-name"),
                sc(
                    c(
                      b(str("equals"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-prefix"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-suffix"),
                          c(
                                arg
                          )
                      ),
                      b(str("matches"),
                          c(
                                arg
                          )
                      )
                    )
                )
            ).as(:oneline),
            b(str("nas-ip-address"),
                sc(
                    b(str("equals"),
                        c(
                              ipv4prefix
                        )
                    )
                )
            ).as(:oneline),
            b(str("calling-station-id"),
                sc(
                    c(
                      b(str("equals"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-prefix"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-suffix"),
                          c(
                                arg
                          )
                      ),
                      b(str("matches"),
                          c(
                                arg
                          )
                      )
                    )
                )
            ).as(:oneline),
            b(str("called-station-id"),
                sc(
                    c(
                      b(str("equals"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-prefix"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-suffix"),
                          c(
                                arg
                          )
                      ),
                      b(str("matches"),
                          c(
                                arg
                          )
                      )
                    )
                )
            ).as(:oneline),
            b(str("class"),
                sc(
                    c(
                      b(str("equals"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-prefix"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-suffix"),
                          c(
                                arg
                          )
                      ),
                      b(str("matches"),
                          c(
                                arg
                          )
                      )
                    )
                )
            ).as(:oneline),
            b(str("threegpp-imsi"),
                sc(
                    c(
                      b(str("equals"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-prefix"),
                          c(
                                arg
                          )
                      ),
                      b(str("has-suffix"),
                          c(
                                arg
                          )
                      ),
                      b(str("matches"),
                          c(
                                arg
                          )
                      )
                    )
                )
            ).as(:oneline),
            b(str("framed-ip-address"),
                sc(
                    b(str("equals"),
                        c(
                              ipv4prefix
                        )
                    )
                )
            ).as(:oneline),
            b(str("framed-ipv6-prefix"),
                sc(
                    b(str("equals"),
                        c(
                              ipv6prefix
                        )
                    )
                )
            ).as(:oneline),
            b(a(str("attribute"), arg),
                c(
                    a(str("code"), arg),
                    a(str("vendor-id"), arg),
                    b(str("format"),
                        sc(
                            c(
                              b(str("string"),
                                  c(
                                      c(
                                        b(str("equals"),
                                            c(
                                                  arg
                                            )
                                        ),
                                        b(str("has-prefix"),
                                            c(
                                                  arg
                                            )
                                        ),
                                        b(str("has-suffix"),
                                            c(
                                                  arg
                                            )
                                        ),
                                        b(str("matches"),
                                            c(
                                                  arg
                                            )
                                        )
                                      )
                                  )
                              ),
                              b(str("time"),
                                  c(
                                      c(
                                        b(str("equals"),
                                            c(
                                                  time
                                            )
                                        ),
                                        b(str("greater-than"),
                                            c(
                                                  time
                                            )
                                        ),
                                        b(str("less-than"),
                                            c(
                                                  time
                                            )
                                        )
                                      )
                                  )
                              ),
                              b(str("integer"),
                                  c(
                                      c(
                                        b(str("equals"),
                                            c(
                                                arg
                                            )
                                        ),
                                        b(str("greater-than"),
                                            c(
                                                arg
                                            )
                                        ),
                                        b(str("less-than"),
                                            c(
                                                arg
                                            )
                                        )
                                      )
                                  )
                              ),
                              b(str("v4address"),
                                  c(
                                      b(str("equals"),
                                          c(
                                                ipv4prefix
                                          )
                                      )
                                  )
                              ),
                              b(str("v6prefix"),
                                  c(
                                      b(str("equals"),
                                          c(
                                                ipv6prefix
                                          )
                                      )
                                  )
                              ),
                              b(str("v6address"),
                                  c(
                                      b(str("equals"),
                                          c(
                                                ipv6prefix
                                          )
                                      )
                                  )
                              )
                            )
                        )
                    ).as(:oneline)
                )
            )
        )
    end

    rule(:tdf_domain) do
      b(arg.as(:arg),
        c(
            b(str("subscriber-type"),
              (str("ip") | str("ifl"))
            ),
            b(str("subscriber-exclude-prefix"),
                c(
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    a(str("network"), arg)
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    a(str("network"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            a(str("pcef-profile"), arg),
            b(str("tdf-interface"),
              interface_unit
            ),
            b(str("maximum-bit-rate"),
                c(
                    a(str("uplink"), arg),
                    a(str("downlink"), arg)
                )
            ),
            b(str("burst-size"),
                c(
                    a(str("uplink"), arg),
                    a(str("downlink"), arg)
                )
            ),
            a(str("charging-profile"), arg),
            b(str("service-mode"),
              (str("maintenance"))
            ),
            b(str("call-rate-statistics"),
                c(
                    a(str("interval"), arg),
                    a(str("history"), arg)
                )
            ),
            b(str("ip-subscriber"),
                c(
                    a(str("access-interfaces"), arg),
                    b(str("subscriber-attach-method"),
                      (str("radius-accounting") | str("packet-triggered") | str("pcrf-initiated"))
                    ),
                    b(str("subscription-id"),
                        c(
                            b(str("subscription-id-options"),
                              subscription_id_set
                            ),
                            b(str("constant"),
                                sc(
                                      arg
                                )
                            ).as(:oneline),
                            a(str("use-class-regular-expression"), arg),
                            b(str("use-class"),
                                c(
                                    a(str("regex"), arg),
                                    a(str("pattern"), arg),
                                    b(str("subscription-id-type"),
                                      (str("imsi") | str("msisdn") | str("nai") | str("sip-uri") | str("private"))
                                    )
                                )
                            )
                        )
                    ),
                    b(str("immediate-accounting-response"),
                      (str("enable") | str("disable"))
                    ),
                    b(str("subscriber-address"),
                        c(
                            b(str("inet"),
                                c(
                                    a(str("pool"), arg)
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    a(str("pool"), arg)
                                )
                            )
                        )
                    ),
                    a(str("maximum-subscribers"), arg),
                    a(str("idle-timeout"), arg),
                    b(str("default-local-policy"),
                        c(
                            b(str("flow-action"),
                              (str("forward") | str("drop"))
                            ),
                            b(str("maximum-bit-rate"),
                                sc(
                                    a(str("uplink"), arg),
                                    a(str("downlink"), arg)
                                )
                            ).as(:oneline),
                            b(str("burst-size"),
                                c(
                                    a(str("uplink"), arg),
                                    a(str("downlink"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("ifl-subscriber"),
                c(
                      tdf_ifl_subscriber
                )
            )
        )
      )
    end

    rule(:subscription_id_set) do
      b(arg.as(:arg),
        c(
            b(str("id-components"),
              (str("use-imsi") | str("use-msisdn") | str("use-nai") | str("use-username") | str("use-realm") | str("use-nas-port") | str("use-nas-port-id") | str("use-class"))
            )
        )
      )
    end

    rule(:tdf_ifl_subscriber) do
      b(arg.as(:arg),
        c(
            a(str("access-interfaces"), arg)
        )
      )
    end

    rule(:unified_edge_tdf_system) do
        c(
            b(str("session-pics"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("service-mode"),
                              (str("maintenance"))
                            )
                        )
                    )
                )
            ),
            b(str("service-pics"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("service-mode"),
                              (str("maintenance"))
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:upgrade_group_fpcs) do
      b(arg.as(:arg),
        c(
            a(str("fpcs"), arg)
        )
      )
    end

    rule(:upgrade_group_type) do
      b(arg.as(:arg),
        c(
            a(str("satellite"), arg)
        )
      )
    end

    rule(:urlf_profile_object) do
      b(arg.as(:arg),
        c(
            a(str("url-filter-database"), arg),
            a(str("global-dns-filter-stats-log-timer"), arg),
            b(str("security-intelligence-policy"),
                c(
                    b(str("file-type"),
                      (str("txt") | str("json"))
                    ),
                    b(str("threat-level"),
                      threat_level_object
                    )
                )
            ),
            b(str("dns-filter"),
              dns_filter_object
            ),
            b(str("url-filter-template"),
              urlf_template_object
            ),
            b(str("dns-filter-template"),
              dnsf_template_object
            )
        )
      )
    end

    rule(:dns_filter_object) do
        c(
            a(str("database-file"), arg),
            b(str("dns-server"),
              ipaddr
            ),
            b(str("hash-key"),
                sc(
                    c(
                      a(str("ascii-text"), arg),
                      a(str("hexadecimal"), arg)
                    )
                )
            ).as(:oneline),
            b(str("hash-method"),
              (str("hmac-sha2-256"))
            ),
            a(str("statistics-log-timer"), arg),
            a(str("dns-resp-ttl"), arg),
            a(str("wildcarding-level"), arg)
        )
    end

    rule(:dnsf_template_object) do
      b(arg.as(:arg),
        c(
            b(str("dns-filter"),
              dns_filter_object
            ),
            b(str("client-interfaces"),
              interface_unit
            ),
            b(str("server-interfaces"),
              interface_unit
            ),
            b(str("client-routing-instance"),
              (str("inet.0") | arg)
            ),
            b(str("server-routing-instance"),
              (str("inet.0") | arg)
            ),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      dnsf_match_object
                    ),
                    b(str("then"),
                        c(
                            c(
                              str("dns-sinkhole")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:dnsf_match_object) do
        c(
            b(str("src-ip-prefix"),
              ipprefix
            )
        )
    end

    rule(:threat_level_object) do
      b(arg.as(:arg),
        c(
            b(str("threat-action"),
                c(
                    c(
                      str("accept"),
                      str("log"),
                      str("drop"),
                      str("drop-and-log"),
                      str("drop-and-sample"),
                      str("drop-log-and-sample"),
                      str("log-and-sample"),
                      str("sample")
                    )
                )
            )
        )
      )
    end

    rule(:urlf_template_object) do
      b(arg.as(:arg),
        c(
            b(str("client-interfaces"),
              interface_unit
            ),
            b(str("server-interfaces"),
              interface_unit
            ),
            b(str("dns-source-interface"),
              interface_unit
            ),
            b(str("dns-routing-instance"),
              (str("inet.0") | arg)
            ),
            b(str("client-routing-instance"),
              (str("inet.0") | arg)
            ),
            b(str("dns-server"),
              ipaddr
            ),
            a(str("dns-resolution-interval"), arg),
            a(str("dns-retries"), arg),
            a(str("dns-resolution-rate"), arg),
            a(str("url-filter-database"), arg),
            str("disable-url-ip-filtering"),
            b(a(str("term"), arg),
                c(
                    b(str("from"),
                      urlf_match_object
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("redirect-url"), arg),
                              a(str("custom-page"), arg),
                              a(str("http-status-code"), arg),
                              str("tcp-reset"),
                              str("accept")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:urlf_match_object) do
        c(
            b(str("src-ip-prefix"),
              ipprefix
            ),
            a(str("dest-ports"), arg)
        )
    end

    rule(:urlf_traceoptions_object) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
            ),
            a(str("flag"), enum(str("normal") | str("config") | str("dns") | str("timer") | str("connect") | str("parse") | str("statistics") | str("system") | str("operational-commands") | str("filter") | str("gencfg") | str("routing") | str("snmp") | str("all"))).as(:oneline)
        )
    end

    rule(:v3_user_config) do
      b(arg.as(:arg),
        c(
            c(
              b(str("authentication-md5"),
                auth_object
              ),
              b(str("authentication-sha"),
                auth_object
              ),
              str("authentication-none")
            ),
            c(
              b(str("privacy-des"),
                priv_object
              ),
              b(str("privacy-3des"),
                priv_object
              ),
              b(str("privacy-aes128"),
                priv_object
              ),
              str("privacy-none")
            )
        )
      )
    end

    rule(:auth_object) do
        c(
            a(str("authentication-password"), arg),
            b(str("authentication-key"),
              unreadable
            )
        )
    end

    rule(:priv_object) do
        c(
            a(str("privacy-password"), arg),
            b(str("privacy-key"),
              unreadable
            )
        )
    end

    rule(:v6_relay_option_interface_id_type) do
        c(
            b(str("prefix"),
                c(
                    str("host-name"),
                    str("logical-system-name"),
                    str("routing-instance-name")
                )
            ),
            b(str("use-interface-description"),
              (str("logical") | str("device"))
            ),
            str("use-vlan-id"),
            str("no-vlan-interface-name"),
            str("include-irb-and-l2"),
            b(str("use-option-82"),
              v6_relay_option_cid_rid_action
            ),
            b(str("keep-incoming-interface-id"),
              v6_relay_option_cid_rid_action
            )
        )
    end

    rule(:v6_relay_option_cid_rid_action) do
        c(
            str("strict")
        )
    end

    rule(:v6_relay_option_remote_id_type) do
        c(
            b(str("prefix"),
                c(
                    str("host-name"),
                    str("logical-system-name"),
                    str("routing-instance-name")
                )
            ),
            b(str("use-interface-description"),
              (str("logical") | str("device"))
            ),
            str("use-vlan-id"),
            str("no-vlan-interface-name"),
            str("include-irb-and-l2"),
            b(str("use-option-82"),
              v6_relay_option_cid_rid_action
            ),
            str("keep-incoming-remote-id")
        )
    end

    rule(:v6_server_group_type) do
        c(
                c(
                    arg
                )
        )
    end

    rule(:v6rd_object) do
      b(arg.as(:arg),
        c(
            b(str("softwire-address"),
              ipv4addr
            ),
            b(str("ipv4-prefix"),
              ipv4prefix
            ),
            b(str("v6rd-prefix"),
              ipv6prefix
            ),
            a(str("mtu-v4"), arg)
        )
      )
    end

    rule(:vchassis_trace_file_type) do
        ca(
            str("replace"),
            a(str("size"), arg),
            a(str("files"), arg),
            str("no-stamp"),
            str("world-readable"),
            str("no-world-readable")
        ).as(:oneline)
    end

    rule(:vendor_object) do
      b(arg.as(:arg),
        c(
            a(str("product-name"), arg)
        )
      )
    end

    rule(:version_ipfix_template) do
      b(arg.as(:arg),
        c(
            a(str("flow-active-timeout"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("template-id"), arg),
            a(str("option-template-id"), arg),
            a(str("observation-domain-id"), arg),
            b(str("nexthop-learning"),
                c(
                      (str("enable") | str("disable"))
                )
            ),
            b(str("template-refresh-rate"),
                c(
                    a(str("packets"), arg),
                    a(str("seconds"), arg)
                )
            ),
            b(str("option-refresh-rate"),
                c(
                    a(str("packets"), arg),
                    a(str("seconds"), arg)
                )
            ),
            c(
              b(str("ipv4-template"),
                  c(
                      b(str("export-extension"),
                          c(
                              c(
                                str("flow-dir"),
                                str("app-id")
                              )
                          )
                      )
                  )
              ),
              b(str("ipv6-template"),
                  c(
                      b(str("export-extension"),
                          c(
                              c(
                                str("flow-dir"),
                                str("app-id")
                              )
                          )
                      )
                  )
              ),
              str("vpls-template"),
              str("bridge-template"),
              b(str("mpls-template"),
                  c(
                      a(str("label-position"), arg)
                  )
              ),
              b(str("mpls-ipv4-template"),
                  c(
                      a(str("label-position"), arg)
                  )
              )
            ),
            b(str("tunnel-observation"),
                c(
                    str("mpls-over-udp"),
                    str("ipv4"),
                    str("ipv6")
                )
            ),
            b(str("flow-key"),
                c(
                    str("flow-direction"),
                    str("vlan-id"),
                    str("output-interface")
                )
            )
        )
      )
    end

    rule(:version9_template) do
      b(arg.as(:arg),
        c(
            a(str("flow-active-timeout"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("template-id"), arg),
            a(str("option-template-id"), arg),
            a(str("source-id"), arg),
            b(str("nexthop-learning"),
                c(
                      (str("enable") | str("disable"))
                )
            ),
            b(str("template-refresh-rate"),
                c(
                    a(str("packets"), arg),
                    a(str("seconds"), arg)
                )
            ),
            b(str("option-refresh-rate"),
                c(
                    a(str("packets"), arg),
                    a(str("seconds"), arg)
                )
            ),
            c(
              b(str("mpls-ipv4-template"),
                  c(
                      a(str("label-position"), arg)
                  )
              ),
              b(str("mpls-template"),
                  c(
                      a(str("label-position"), arg)
                  )
              ),
              b(str("ipv6-template"),
                  c(
                      b(str("export-extension"),
                          c(
                              c(
                                str("flow-dir"),
                                str("app-id")
                              )
                          )
                      ),
                      b(str("nexthop-options"),
                          c(
                              c(
                                b(str("mpls"),
                                    c(
                                        a(str("label-position"), arg)
                                    )
                                )
                              )
                          )
                      )
                  )
              ),
              str("peer-as-billing-template"),
              b(str("ipv4-template"),
                  c(
                      b(str("export-extension"),
                          c(
                              c(
                                str("flow-dir"),
                                str("app-id")
                              )
                          )
                      ),
                      b(str("nexthop-options"),
                          c(
                              c(
                                b(str("mpls"),
                                    c(
                                        a(str("label-position"), arg)
                                    )
                                )
                              )
                          )
                      )
                  )
              ),
              str("vpls-template"),
              str("bridge-template")
            ),
            b(str("tunnel-observation"),
                c(
                    str("mpls-over-udp"),
                    str("ipv4"),
                    str("ipv6")
                )
            ),
            b(str("flow-key"),
                c(
                    str("flow-direction"),
                    str("vlan-id"),
                    str("output-interface")
                )
            )
        )
      )
    end

    rule(:virtual_interface_indications_object) do
        c(
            b(str("virtual-interface-up"),
              pgcp_virtual_interface_up_object
            ),
            b(str("virtual-interface-down"),
              pgcp_virtual_interface_down_object
            )
        )
    end

    rule(:pgcp_virtual_interface_down_object) do
        c(
            b(str("graceful"),
              (str("none") | str("graceful-905"))
            ),
            b(str("administrative"),
              (str("forced-905") | str("forced-906") | str("none"))
            ),
            b(str("failure"),
              (str("forced-904") | str("forced-906") | str("none"))
            ),
            b(str("link-loss"),
              (str("forced-906") | str("none"))
            )
        )
    end

    rule(:pgcp_virtual_interface_up_object) do
        c(
            b(str("warm"),
              (str("restart-900") | str("none"))
            ),
            b(str("cancel-graceful"),
              (str("none") | str("restart-918"))
            )
        )
    end

    rule(:vlan_policy) do
      b((str("all") | arg).as(:arg),
        c(
            b(str("policy"),
                ca(
                    c(
                      str("stateful"),
                      str("stateless")
                    )
                )
            )
        )
      )
    end

    rule(:vlan_slaacd) do
      (str("all") | arg).as(:arg)
    end

    rule(:vlan_types) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            c(
              b(str("vlan-id"),
                (str("all") | str("none") | arg)
              ),
              a(str("vlan-id-list"), arg),
              b(str("vlan-tags"),
                  sc(
                      a(str("outer"), arg),
                      a(str("inner"), arg)
                  )
              ).as(:oneline)
            ),
            a(str("interface"), arg | arg),
            b(str("l3-interface"),
              interface_unit
            ),
            str("no-local-switching"),
            b(str("forwarding-options"),
              juniper_ethernet_switching_forwarding_options
            ),
            b(str("multicast-snooping-options"),
              juniper_multicast_snooping_options
            ),
            b(str("switch-options"),
              juniper_protocols_vlan
            ),
            b(str("domain-type"),
              (str("bridge"))
            ),
            str("no-irb-layer-2-copy"),
            a(str("service-id"), arg),
            a(str("domain-id"), arg),
            str("mcae-mac-synchronize"),
            b(str("proxy-mac"),
                c(
                    str("irb"),
                      mac_unicast
                )
            ),
            str("mcae-mac-flush"),
            b(str("private-vlan"),
              (str("isolated") | str("community"))
            ),
            a(str("isolated-vlan"), arg),
            a(str("community-vlans"), arg),
            b(str("vxlan"),
                c(
                    str("ovsdb-managed"),
                    a(str("vni"), arg),
                    b(str("multicast-group"),
                      ipv4addr
                    ),
                    str("encapsulate-inner-vlan"),
                    str("decapsulate-accept-inner-vlan"),
                    a(str("unreachable-vtep-aging-timer"), arg),
                    str("ingress-node-replication")
                )
            )
        )
      )
    end

    rule(:juniper_ethernet_switching_forwarding_options) do
        c(
            b(str("filter"),
                c(
                    a(str("input"), arg),
                    a(str("output"), arg)
                )
            ),
            b(str("flood"),
                c(
                    a(str("input"), arg)
                )
            ),
            b(str("dhcp-relay"),
              jdhcp_relay_type
            ),
            b(str("dhcp-security"),
              jdhcp_security_type
            ),
            b(str("fip-security"),
              fip_security_type
            )
        )
    end

    rule(:fip_security_type) do
        c(
            b(a(str("interface"), arg),
                c(
                    str("fcoe-trusted"),
                    str("no-fcoe-trusted")
                )
            ),
            a(str("fc-map"), arg),
            b(str("examine-vn2vf"),
                c(
                    str("satellite")
                )
            ),
            b(str("examine-vn2vn"),
                c(
                    a(str("beacon-period"), arg)
                )
            )
        )
    end

    rule(:juniper_protocols_vlan) do
        c(
            b(str("mac-table-size"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop"))
                    )
                )
            ),
            b(str("mac-ip-table-size"),
                c(
                      arg
                )
            ),
            b(str("interface-mac-limit"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                    )
                )
            ),
            b(str("interface-mac-ip-limit"),
                c(
                      arg
                )
            ),
            b(str("mac-move-limit"),
                ca(
                    b(str("packet-action"),
                      (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log") | str("vlan-member-shutdown"))
                    ),
                    b(a(str("interface"), arg),
                        c(
                            a(str("action-priority"), arg)
                        )
                    )
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("no-normalization"),
            str("mac-statistics"),
            b(str("static-rvtep-mac"),
                c(
                    b(str("mac"),
                        s(
                                arg,
                          a(str("remote-vtep"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        ca(
                            str("disable"),
                            b(str("packet-action"),
                              (str("none") | str("drop") | str("log") | str("shutdown") | str("drop-and-log"))
                            )
                        )
                    ),
                    b(str("vpws-service-id"),
                        c(
                            a(str("local"), arg),
                            a(str("remote"), arg)
                        )
                    ),
                    b(str("protect-interface"),
                      interface_name
                    ),
                    a(str("action-priority"), arg),
                    a(str("remote-site-id"), arg),
                    a(str("target-attachment-identifier"), arg),
                    str("flow-label-transmit"),
                    str("flow-label-receive"),
                    b(str("encapsulation-type"),
                      (str("atm-aal5") | str("atm-cell") | str("atm-cell-port-mode") | str("atm-cell-vp-mode") | str("atm-cell-vc-mode") | str("frame-relay") | str("ppp") | str("cisco-hdlc") | str("ethernet-vlan") | str("ethernet") | str("interworking") | str("frame-relay-port-mode") | str("satop-t1") | str("satop-e1") | str("satop-t3") | str("satop-e3") | str("cesop"))
                    ),
                    str("ignore-encapsulation-mismatch"),
                    a(str("mtu"), arg),
                    str("ignore-mtu-mismatch"),
                    c(
                      str("control-word"),
                      str("no-control-word")
                    ),
                    str("pseudowire-status-tlv"),
                    b(str("oam"),
                        c(
                            a(str("ping-interval"), arg),
                            a(str("ping-multiplier"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    b(str("version"),
                                      (str("0") | str("1") | str("automatic"))
                                    ),
                                    a(str("minimum-interval"), arg),
                                    a(str("minimum-transmit-interval"), arg),
                                    a(str("minimum-receive-interval"), arg),
                                    a(str("multiplier"), arg),
                                    c(
                                      str("no-adaptation")
                                    ),
                                    b(str("transmit-interval"),
                                        c(
                                            a(str("minimum-interval"), arg),
                                            a(str("threshold"), arg)
                                        )
                                    ),
                                    b(str("detection-time"),
                                        c(
                                            a(str("threshold"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("community"), arg),
                    b(a(str("static-mac"), arg),
                        c(
                            a(str("vlan-id"), arg)
                        )
                    ),
                    b(str("interface-mac-ip-limit"),
                        c(
                              arg
                        )
                    ),
                    str("no-mac-learning"),
                    str("mac-pinning"),
                    a(str("description"), quote | arg),
                    str("persistent-learning")
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    b(str("level"),
                      (str("error") | str("warning") | str("notice") | str("info") | str("verbose") | str("all"))
                    ),
                    a(str("flag"), enum(str("configuration") | str("routing-socket") | str("interface-device") | str("interface-logical") | str("interface-family") | str("learning-domain") | str("ipc") | str("mac-learning") | str("initialization") | str("flood-next-hop") | str("storm-control") | str("unknown-unicast-forwarding") | str("all"))).as(:oneline)
                )
            )
        )
    end

    rule(:vlan_map) do
        c(
            c(
              str("push"),
              str("swap"),
              str("pop"),
              str("push-push"),
              str("swap-push"),
              str("swap-swap"),
              str("pop-swap"),
              str("pop-pop")
            ),
            a(str("tag-protocol-id"), arg),
            b(str("inner-tag-protocol-id"),
              (arg | arg)
            ),
            b(str("vlan-id"),
              (arg | arg)
            ),
            b(str("inner-vlan-id"),
              (arg | arg)
            )
        )
    end

    rule(:vpls_filter) do
      b(arg.as(:arg),
        c(
            a(str("accounting-profile"), arg),
            str("interface-specific"),
            str("physical-interface-filter"),
            str("instance-shared"),
            b(a(str("term"), arg),
                c(
                    a(str("filter"), arg),
                    b(str("from"),
                        c(
                            c(
                              a(str("interface-group"), arg),
                              a(str("interface-group-except"), arg)
                            ),
                            c(
                              b(str("ether-type"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              ),
                              b(str("ether-type-except"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              )
                            ),
                            c(
                              b(str("vlan-ether-type"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              ),
                              b(str("vlan-ether-type-except"),
                                    (str("ipv4") | str("ipv6") | str("arp") | str("appletalk") | str("sna") | str("aarp") | str("ppp") | str("mpls-unicast") | str("mpls-multicast") | str("pppoe-discovery") | str("pppoe-session") | str("oam") | str("fcoe") | str("fip") | str("vlan") | arg)
                              )
                            ),
                            b(str("destination-mac-address"),
                              firewall_mac_addr_object
                            ),
                            b(str("source-mac-address"),
                              firewall_mac_addr_object
                            ),
                            c(
                              a(str("forwarding-class"), arg),
                              a(str("forwarding-class-except"), arg)
                            ),
                            c(
                              b(str("loss-priority"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              ),
                              b(str("loss-priority-except"),
                                    (str("low") | str("high") | str("medium-low") | str("medium-high"))
                              )
                            ),
                            c(
                              a(str("learn-vlan-id"), arg),
                              a(str("learn-vlan-id-except"), arg)
                            ),
                            c(
                              a(str("learn-vlan-1p-priority"), arg),
                              a(str("learn-vlan-1p-priority-except"), arg)
                            ),
                            c(
                              a(str("user-vlan-id"), arg),
                              a(str("user-vlan-id-except"), arg)
                            ),
                            c(
                              a(str("user-vlan-1p-priority"), arg),
                              a(str("user-vlan-1p-priority-except"), arg)
                            ),
                            c(
                              a(str("learn-vlan-dei"), arg),
                              a(str("learn-vlan-dei-except"), arg)
                            ),
                            c(
                              b(str("traffic-type"),
                                    (str("broadcast") | str("multicast") | str("unknown-unicast") | str("known-unicast"))
                              ),
                              b(str("traffic-type-except"),
                                    (str("broadcast") | str("multicast") | str("unknown-unicast") | str("known-unicast"))
                              )
                            ),
                            b(str("ip-source-address"),
                              firewall_addr_object
                            ),
                            b(str("ip-destination-address"),
                              firewall_addr_object
                            ),
                            b(str("ip-address"),
                              firewall_addr_object
                            ),
                            c(
                              b(str("ip-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ip-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("dscp"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("dscp-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            c(
                              b(str("ip-precedence"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              ),
                              b(str("ip-precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | arg)
                              )
                            ),
                            c(
                              b(str("source-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("source-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("destination-port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("destination-port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            c(
                              b(str("port"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              ),
                              b(str("port-except"),
                                    (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
                              )
                            ),
                            a(str("tcp-flags"), arg),
                            c(
                              b(str("icmp-type"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              ),
                              b(str("icmp-type-except"),
                                    (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
                              )
                            ),
                            c(
                              b(str("icmp-code"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              ),
                              b(str("icmp-code-except"),
                                    (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
                              )
                            ),
                            b(str("interface"),
                              match_interface_object
                            ),
                            b(str("interface-set"),
                              match_interface_set_object
                            ),
                            b(str("source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ipv6-destination-address"),
                              firewall_addr6_object
                            ),
                            b(str("ipv6-source-address"),
                              firewall_addr6_object
                            ),
                            b(str("ipv6-address"),
                              firewall_addr6_object
                            ),
                            c(
                              b(str("ipv6-next-header"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ipv6-next-header-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("dstopts") | str("routing") | str("fragment") | str("hop-by-hop") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("ipv6-payload-protocol"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              ),
                              b(str("ipv6-payload-protocol-except"),
                                    (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | str("ipv6") | str("no-next-header") | str("vrrp") | arg)
                              )
                            ),
                            c(
                              b(str("ipv6-traffic-class"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              ),
                              b(str("ipv6-traffic-class-except"),
                                    (str("af11") | str("af12") | str("af13") | str("af21") | str("af22") | str("af23") | str("af31") | str("af32") | str("af33") | str("af41") | str("af42") | str("af43") | str("ef") | str("cs0") | str("cs1") | str("cs2") | str("cs3") | str("cs4") | str("cs5") | str("cs6") | str("cs7") | str("be") | arg)
                              )
                            ),
                            b(str("ipv6-source-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ipv6-destination-prefix-list"),
                              firewall_prefix_list
                            ),
                            b(str("ipv6-prefix-list"),
                              firewall_prefix_list
                            ),
                            c(
                              b(str("flexible-match-mask"),
                                match_l2_flexible_mask
                              )
                            ),
                            c(
                              b(str("flexible-match-range"),
                                match_l2_flexible_range
                              )
                            ),
                            c(
                              a(str("policy-map"), arg),
                              a(str("policy-map-except"), arg)
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("single-packet-rate"), arg),
                                        a(str("two-rate"), arg),
                                        a(str("two-packet-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            c(
                              str("clear-policy-map"),
                              a(str("policy-map"), arg)
                            ),
                            a(str("count"), arg),
                            b(str("loss-priority"),
                              (str("low") | str("high") | str("medium-low") | str("medium-high"))
                            ),
                            a(str("forwarding-class"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              b(str("next"),
                                (str("term"))
                              )
                            ),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("next-hop-group"), arg),
                            str("sample"),
                            str("log"),
                            str("syslog")
                        )
                    )
                )
            )
        )
      )
    end

    rule(:vrrp_group) do
      b(arg.as(:arg),
        c(
            c(
              b(str("virtual-address"),
                ipv4addr
              ),
              b(str("virtual-inet6-address"),
                ipv6addr
              )
            ),
            b(str("virtual-link-local-address"),
              ipv6addr
            ),
            a(str("priority"), arg),
            str("preferred"),
            c(
              a(str("advertise-interval"), arg),
              a(str("fast-interval"), arg),
              a(str("inet6-advertise-interval"), arg)
            ),
            c(
              b(str("preempt"),
                  c(
                      a(str("hold-time"), arg)
                  )
              ),
              str("no-preempt")
            ),
            c(
              str("accept-data"),
              str("no-accept-data")
            ),
            b(str("authentication-type"),
              (str("md5") | str("simple"))
            ),
            b(str("authentication-key"),
              unreadable
            ),
            b(str("track"),
                c(
                    a(str("priority-hold-time"), arg),
                    b(a(str("interface"), arg),
                        c(
                            b(a(str("bandwidth-threshold"), arg),
                                sc(
                                    a(str("priority-cost"), arg)
                                )
                            ).as(:oneline),
                            a(str("priority-cost"), arg)
                        )
                    ),
                    b(str("route"),
                        s(
                                arg,
                          a(str("routing-instance"), arg),
                          c(
                            a(str("priority-cost"), arg)
                          )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("vrrp-inherit-from"),
                c(
                    b(str("active-interface"),
                      interface_unit
                    ),
                    a(str("active-group"), arg)
                )
            ),
            a(str("advertisements-threshold"), arg)
        )
      )
    end

    rule(:web_config) do
        c(
            b(a(str("profile"), arg),
                c(
                    b(a(str("proxy-address"), arg),
                        c(
                            b(str("ip"),
                              ipprefix
                            ),
                            a(str("port"), arg)
                        )
                    ),
                    b(str("dynamic-web-application"),
                          (str("any") | arg)
                    ),
                    b(str("dynamic-web-application-group"),
                          (str("any") | arg)
                    ),
                    str("drop-on-dns-error")
                )
            )
        )
    end

    rule(:web_proxy_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("brief") | str("detail") | str("extensive") | str("verbose"))
            ),
            a(str("flag"), enum(str("cli-configuration") | str("ipc") | str("svc-config") | str("flow-session") | str("all"))).as(:oneline)
        )
    end

    rule(:write_option_82_type) do

    end

    rule(:juniper_ethernet_options) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      esp_trace_file_type
                    ),
                    a(str("flag"), str("parse") | str("regex-parse") | str("config-internal") | str("normal") | str("general") | str("state") | str("task") | str("timer") | str("krt") | str("vlan") | str("forwarding-database") | str("nexthop") | str("interface") | str("lib") | str("stp") | str("filter") | str("access-security") | str("rtg") | str("ip-source-guard") | str("analyzer") | str("layer2-protocol-tunneling") | str("unknown-unicast-forwarding") | str("all"),
                        sc(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("voip"),
                c(
                    a(str("interface"), str("name") | str("access-ports"),
                        c(
                            a(str("vlan"), arg),
                            a(str("forwarding-class"), arg)
                        )
                    )
                )
            ),
            b(str("unknown-unicast-forwarding"),
                c(
                    b(a(str("vlan"), arg),
                        c(
                            b(str("interface"),
                              interface_name
                            )
                        )
                    )
                )
            ),
            b(str("dot1q-tunneling"),
                c(
                    b(str("ether-type"),
                      (str("0x8100") | str("0x9100") | str("0x88a8"))
                    )
                )
            ),
            b(str("mac-notification"),
                c(
                    a(str("notification-interval"), arg)
                )
            ),
            b(str("interfaces"),
                c(
                    b(str("esw-interface"),
                      esw_interface_type
                    )
                )
            ),
            b(str("mac-table-aging-time"),
              mac_aging_time_config
            ),
            str("nonstop-bridging"),
            b(str("static"),
                c(
                    b(a(str("vlan"), arg),
                        c(
                            b(a(str("mac"), arg),
                                sc(
                                    b(str("next-hop"),
                                      interface_name
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("secure-access-port"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("mac-limit"),
                                sc(
                                    a(str("limit"), arg),
                                    b(str("action"),
                                      (str("none") | str("drop") | str("log") | str("shutdown"))
                                    )
                                )
                            ).as(:oneline),
                            b(str("static-ip"),
                              juniper_ip_mac_static
                            ),
                            b(str("allowed-mac"),
                              mac_addr
                            ),
                            str("no-allowed-mac-log"),
                            str("dhcp-trusted"),
                            str("no-dhcp-trusted"),
                            str("fcoe-trusted"),
                            str("no-fcoe-trusted"),
                            str("persistent-learning")
                        )
                    ),
                    a(str("vlan"), str("all") | arg,
                        c(
                            c(
                              b(str("arp-inspection"),
                                  sc(
                                      a(str("forwarding-class"), arg)
                                  )
                              ).as(:oneline),
                              str("no-arp-inspection")
                            ),
                            c(
                              b(str("examine-dhcp"),
                                  sc(
                                      a(str("forwarding-class"), arg)
                                  )
                              ).as(:oneline),
                              str("no-examine-dhcp")
                            ),
                            str("examine-fip"),
                            b(str("mac-move-limit"),
                                sc(
                                    a(str("limit"), arg),
                                    b(str("action"),
                                      (str("none") | str("drop") | str("log") | str("shutdown"))
                                    )
                                )
                            ).as(:oneline),
                            str("ip-source-guard"),
                            str("no-ip-source-guard"),
                            b(str("dhcp-option82"),
                              dhcp_option82_type
                            )
                        )
                    ),
                    b(str("dhcp-snooping-file"),
                        c(
                            b(str("location"),
                              filename
                            ),
                            a(str("write-interval"), arg),
                            a(str("timeout"), arg)
                        )
                    )
                )
            ),
            b(a(str("authentication-whitelist"), arg),
                c(
                    a(str("vlan-assignment"), arg),
                    b(str("interface"),
                      interface_name
                    )
                )
            ),
            b(str("analyzer"),
              analyzer_type
            ),
            b(str("port-error-disable"),
                c(
                    a(str("disable-timeout"), arg)
                )
            ),
            b(str("bpdu-block"),
                c(
                    a(str("interface"), str("all") | arg),
                    a(str("disable-timeout"), arg)
                )
            ),
            b(str("redundant-trunk-group"),
                c(
                    b(a(str("group"), arg),
                        c(
                            a(str("preempt-cutover-timer"), arg),
                            a(str("description"), quote | arg),
                            b(a(str("interface"), arg),
                                c(
                                    str("primary")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("storm-control"),
                c(
                    str("action-shutdown"),
                    a(str("interface"), str("all") | arg,
                        c(
                            a(str("bandwidth"), arg),
                            str("no-broadcast"),
                            str("no-unknown-unicast"),
                            a(str("level"), arg),
                            c(
                              str("multicast"),
                              str("no-multicast"),
                              str("no-registered-multicast"),
                              str("no-unregistered-multicast")
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:analyzer_type) do
      b(arg.as(:arg),
        c(
            a(str("ratio"), arg),
            b(str("loss-priority"),
              (str("low") | str("high"))
            ),
            b(str("input"),
              analyzer_input_type
            ),
            b(str("output"),
              analyzer_output_type
            )
        )
      )
    end

    rule(:analyzer_input_type) do
        c(
            b(str("ingress"),
              analyzer_ingress_type
            ),
            b(str("egress"),
              analyzer_egress_type
            )
        )
    end

    rule(:analyzer_egress_type) do
        c(
            b(str("interface"),
              analyzer_egress_interface_type
            ),
            b(str("vlan"),
              analyzer_vlan_type
            )
        )
    end

    rule(:analyzer_ingress_type) do
        c(
            b(str("interface"),
              analyzer_ingress_interface_type
            ),
            b(str("vlan"),
              analyzer_vlan_type
            )
        )
    end

    rule(:analyzer_output_type) do
        c(
            a(str("interface"), arg),
            b(a(str("vlan"), arg),
                c(
                    str("no-tag")
                )
            )
        )
    end

    rule(:analyzer_vlan_type) do
      arg.as(:arg)
    end

    rule(:esw_interface_type) do
      b(arg.as(:arg),
        c(
            str("no-mac-learning")
        )
      )
    end

    rule(:mac_aging_time_config) do
        c(
            c(
              a(str("time"), arg),
              str("unlimited")
            )
        )
    end

    rule(:juniper_ip_mac_static) do
      b(arg.as(:arg),
        c(
            a(str("vlan"), arg),
            b(str("mac"),
              mac_addr
            )
        )
      ).as(:oneline)
    end

    rule(:esp_trace_file_type) do
        ca(
            str("replace"),
            a(str("size"), arg),
            a(str("files"), arg),
            str("no-stamp"),
            str("world-readable"),
            str("no-world-readable")
        ).as(:oneline)
    end

    # Ported from vSRX 18.3R1.9
    rule(:alg_object) do
        c(
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    b(str("level"),
                      (str("brief") | str("detail") | str("extensive") | str("verbose"))
                    )
                )
            ),
            b(str("alg-manager"),
                sc(
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("alg-support-lib"),
                sc(
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("dns"),
                c(
                    str("disable"),
                    a(str("maximum-message-length"), arg),
                    str("oversize-message-drop"),
                    b(str("doctoring"),
                        c(
                            c(
                              str("none"),
                              str("sanity-check")
                            )
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("ftp"),
                sc(
                    str("disable"),
                    str("ftps-extension"),
                    str("line-break-extension"),
                    str("allow-mismatch-ip-address"),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("h323"),
                c(
                    str("disable"),
                    a(str("endpoint-registration-timeout"), arg),
                    str("media-source-port-any"),
                    b(str("application-screen"),
                        c(
                            b(str("unknown-message"),
                                c(
                                    str("permit-nat-applied"),
                                    str("permit-routed")
                                )
                            ),
                            b(str("message-flood"),
                                c(
                                    b(str("gatekeeper"),
                                        sc(
                                            a(str("threshold"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("dscp-rewrite"),
                        c(
                            a(str("code-point"), arg)
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("q931") | str("h245") | str("ras") | str("h225-asn1") | str("h245-asn1") | str("ras-asn1") | str("chassis-cluster") | str("all")),
                                sc(
                                    c(
                                      str("terse"),
                                      str("detail"),
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("mgcp"),
                c(
                    str("disable"),
                    a(str("inactive-media-timeout"), arg),
                    a(str("transaction-timeout"), arg),
                    a(str("maximum-call-duration"), arg),
                    b(str("application-screen"),
                        c(
                            b(str("unknown-message"),
                                c(
                                    str("permit-nat-applied"),
                                    str("permit-routed")
                                )
                            ),
                            b(str("message-flood"),
                                sc(
                                    a(str("threshold"), arg)
                                )
                            ).as(:oneline),
                            b(str("connection-flood"),
                                sc(
                                    a(str("threshold"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("dscp-rewrite"),
                        c(
                            a(str("code-point"), arg)
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("call") | str("decode") | str("error") | str("chassis-cluster") | str("nat") | str("packet") | str("rm") | str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("msrpc"),
                sc(
                    str("disable"),
                    a(str("group-max-usage"), arg),
                    a(str("map-entry-timeout"), arg),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("sunrpc"),
                sc(
                    str("disable"),
                    a(str("group-max-usage"), arg),
                    a(str("map-entry-timeout"), arg),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("rsh"),
                c(
                    str("disable"),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("rtsp"),
                sc(
                    str("disable"),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("sccp"),
                c(
                    str("disable"),
                    a(str("inactive-media-timeout"), arg),
                    b(str("application-screen"),
                        c(
                            b(str("unknown-message"),
                                c(
                                    str("permit-nat-applied"),
                                    str("permit-routed")
                                )
                            ),
                            b(str("call-flood"),
                                sc(
                                    a(str("threshold"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("dscp-rewrite"),
                        c(
                            a(str("code-point"), arg)
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("call") | str("cli") | str("decode") | str("error") | str("chassis-cluster") | str("init") | str("nat") | str("rm") | str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("sip"),
                c(
                    str("disable"),
                    a(str("inactive-media-timeout"), arg),
                    a(str("maximum-call-duration"), arg),
                    a(str("t1-interval"), arg),
                    a(str("t4-interval"), arg),
                    a(str("c-timeout"), arg),
                    str("disable-call-id-hiding"),
                    str("retain-hold-resource"),
                    b(str("hide-via-headers"),
                        c(
                            str("disable")
                        )
                    ),
                    str("distribution-ip"),
                    b(str("application-screen"),
                        c(
                            b(str("unknown-message"),
                                c(
                                    str("permit-nat-applied"),
                                    str("permit-routed")
                                )
                            ),
                            b(str("protect"),
                                c(
                                    b(str("deny"),
                                        c(
                                            c(
                                              a(str("destination-ip"), arg),
                                              str("all")
                                            ),
                                            a(str("timeout"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("dscp-rewrite"),
                        c(
                            a(str("code-point"), arg)
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("call") | str("chassis-cluster") | str("nat") | str("parser") | str("rm") | str("all")),
                                sc(
                                    c(
                                      str("terse"),
                                      str("detail"),
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("sql"),
                sc(
                    str("disable"),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("talk"),
                sc(
                    str("disable"),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("tftp"),
                sc(
                    str("disable"),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("pptp"),
                sc(
                    str("disable"),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ).as(:oneline),
            b(str("ike-esp-nat"),
                c(
                    str("enable"),
                    a(str("esp-gate-timeout"), arg),
                    a(str("esp-session-timeout"), arg),
                    a(str("state-timeout"), arg),
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("twamp"),
                c(
                    b(str("traceoptions"),
                        c(
                            a(str("flag"), enum(str("all")),
                                sc(
                                    c(
                                      str("extensive")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
    end

    rule(:anti_spam_feature) do
        c(
            b(str("sbl"),
              sbl_type
            )
        )
    end

    rule(:anti_virus_feature) do
        c(
            b(str("sophos-engine"),
                c(
                    b(a(str("profile"), arg),
                        c(
                            b(str("fallback-options"),
                              sophos_fallback_settings
                            ),
                            b(str("scan-options"),
                              sophos_scan_options
                            ),
                            b(str("trickling"),
                              anti_virus_trickling
                            ),
                            b(str("notification-options"),
                              anti_virus_notification_options
                            ),
                            b(str("mime-whitelist"),
                                c(
                                    a(str("list"), arg),
                                    a(str("exception"), arg)
                                )
                            ),
                            a(str("url-whitelist"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:anti_virus_notification_options) do
        c(
            b(str("virus-detection"),
                c(
                    b(str("type"),
                      (str("protocol-only") | str("message"))
                    ),
                    str("notify-mail-sender"),
                    str("no-notify-mail-sender"),
                    a(str("custom-message"), arg),
                    a(str("custom-message-subject"), arg)
                )
            ),
            b(str("fallback-block"),
                c(
                    b(str("type"),
                      (str("protocol-only") | str("message"))
                    ),
                    str("notify-mail-sender"),
                    str("no-notify-mail-sender"),
                    a(str("custom-message"), arg),
                    a(str("custom-message-subject"), arg)
                )
            ),
            b(str("fallback-non-block"),
                c(
                    str("notify-mail-recipient"),
                    str("no-notify-mail-recipient"),
                    a(str("custom-message"), arg),
                    a(str("custom-message-subject"), arg)
                )
            )
        )
    end

    rule(:anti_virus_trickling) do
        c(
            a(str("timeout"), arg)
        ).as(:oneline)
    end

    rule(:apbr_rule_type) do
      b(arg.as(:arg),
        c(
            b(str("match"),
                c(
                    b(str("dynamic-application"),
                          (str("junos:UNKNOWN") | arg)
                    ),
                    b(str("dynamic-application-group"),
                          (str("junos:unassigned") | arg)
                    ),
                    b(str("category"),
                          (arg | arg)
                    )
                )
            ),
            b(str("then"),
                c(
                    b(str("routing-instance"),
                        sc(
                            arg
                        )
                    ).as(:oneline),
                    b(str("sla-rule"),
                        c(
                            arg
                        )
                    )
                )
            )
        )
      )
    end

    rule(:appfw_rule_type) do
      b(arg.as(:arg),
        c(
            b(str("match"),
                c(
                    b(str("dynamic-application"),
                          (str("junos:UNKNOWN") | arg)
                    ),
                    b(str("dynamic-application-group"),
                          (str("junos:unassigned") | arg)
                    ),
                    b(str("ssl-encryption"),
                      (str("any") | str("yes") | str("no"))
                    )
                )
            ),
            b(str("then"),
                c(
                    c(
                      str("permit"),
                      b(str("deny"),
                          c(
                              str("block-message")
                          )
                      ),
                      b(str("reject"),
                          c(
                              str("block-message")
                          )
                      )
                    )
                )
            )
        )
      )
    end

    rule(:appqoe_probe_params) do
        c(
            b(str("data-fill"),
                c(
                      arg
                )
            ),
            b(str("data-size"),
                c(
                      arg
                )
            ),
            b(str("probe-interval"),
                c(
                      arg
                )
            ),
            b(str("probe-count"),
                c(
                      arg
                )
            ),
            b(str("burst-size"),
                c(
                      arg
                )
            ),
            b(str("sla-export-interval"),
                c(
                      arg
                )
            ),
            b(str("dscp-code-points"),
                c(
                    arg
                )
            )
        )
    end

    rule(:appqoe_probe_path) do
        c(
            b(str("local"),
              appqoe_node
            ),
            b(str("remote"),
              appqoe_node
            )
        )
    end

    rule(:appqoe_node) do
        c(
            b(str("ip-address"),
                c(
                      ipv4addr
                )
            )
        )
    end

    rule(:appqoe_sla_metric_profile) do
        c(
            b(str("delay-round-trip"),
                c(
                      arg
                )
            ),
            b(str("jitter"),
                c(
                      arg
                )
            ),
            b(str("jitter-type"),
                c(
                    c(
                      str("two-way-jitter"),
                      str("egress-jitter"),
                      str("ingress-jitter")
                    )
                )
            ),
            b(str("packet-loss"),
                c(
                      arg
                )
            ),
            b(str("match"),
                c(
                    c(
                      str("any-one"),
                      str("all")
                    )
                )
            )
        )
    end

    rule(:authentication_source_type) do
      b((str("local-authentication-table") | str("unified-access-control") | str("firewall-authentication") | str("active-directory-authentication-table") | str("aruba-clearpass")).as(:arg),
        c(
            c(
              a(str("priority"), arg)
            )
        )
      )
    end

    rule(:category_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), arg)
        )
      )
    end

    rule(:command_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), arg)
        )
      )
    end

    rule(:content_filtering_feature) do
        c(
            b(a(str("profile"), arg),
                c(
                    a(str("permit-command"), arg),
                    a(str("block-command"), arg),
                    a(str("block-extension"), arg),
                    b(str("block-mime"),
                        c(
                            a(str("list"), arg),
                            a(str("exception"), arg)
                        )
                    ),
                    b(str("block-content-type"),
                        c(
                            str("activex"),
                            str("java-applet"),
                            str("exe"),
                            str("zip"),
                            str("http-cookie")
                        )
                    ),
                    b(str("notification-options"),
                        c(
                            b(str("type"),
                              (str("protocol-only") | str("message"))
                            ),
                            str("notify-mail-sender"),
                            str("no-notify-mail-sender"),
                            a(str("custom-message"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:custom_message_type) do
      b(arg.as(:arg),
        c(
            b(str("type"),
              (str("redirect-url") | str("user-message"))
            ),
            a(str("content"), arg)
        )
      )
    end

    rule(:default_anti_spam_feature) do
        c(
            b(str("type"),
              (str("sbl") | str("anti-spam-none"))
            ),
            a(str("address-whitelist"), arg),
            a(str("address-blacklist"), arg),
            b(str("traceoptions"),
              anti_spam_traceoptions
            ),
            b(str("sbl"),
              default_sbl_type
            )
        )
    end

    rule(:anti_spam_traceoptions) do
        c(
            a(str("flag"), enum(str("manager") | str("sbl") | str("all"))).as(:oneline)
        )
    end

    rule(:default_anti_virus_feature) do
        c(
            b(str("mime-whitelist"),
                c(
                    a(str("list"), arg),
                    a(str("exception"), arg)
                )
            ),
            a(str("url-whitelist"), arg),
            b(str("type"),
              (str("sophos-engine") | str("anti-virus-none"))
            ),
            b(str("traceoptions"),
              anti_virus_traceoptions
            ),
            b(str("sophos-engine"),
                c(
                    b(str("server"),
                        c(
                            a(str("routing-instance"), arg),
                              ipaddr
                        )
                    ),
                    a(str("sxl-timeout"), arg),
                    a(str("sxl-retry"), arg),
                    b(str("pattern-update"),
                      anti_virus_pattern_update
                    ),
                    b(str("fallback-options"),
                      sophos_fallback_settings
                    ),
                    b(str("scan-options"),
                      default_sophos_scan_options
                    ),
                    b(str("trickling"),
                      anti_virus_trickling
                    ),
                    b(str("notification-options"),
                      anti_virus_notification_options
                    )
                )
            )
        )
    end

    rule(:anti_virus_pattern_update) do
        c(
            b(str("email-notify"),
                c(
                    a(str("admin-email"), arg),
                    a(str("custom-message"), arg),
                    a(str("custom-message-subject"), arg)
                )
            ),
            a(str("url"), arg),
            a(str("proxy-profile"), arg),
            a(str("routing-instance"), arg),
            a(str("interval"), arg),
            str("no-autoupdate")
        )
    end

    rule(:anti_virus_traceoptions) do
        c(
            a(str("flag"), enum(str("basic") | str("detail") | str("engine") | str("pattern") | str("updater") | str("manager") | str("worker") | str("sendmail") | str("ipc") | str("event") | str("statistics") | str("all"))).as(:oneline)
        )
    end

    rule(:default_content_filtering_feature) do
        c(
            b(str("type"),
              (str("local") | str("content-filtering-none"))
            ),
            b(str("traceoptions"),
              content_filtering_traceoptions
            ),
            a(str("permit-command"), arg),
            a(str("block-command"), arg),
            a(str("block-extension"), arg),
            b(str("block-mime"),
                c(
                    a(str("list"), arg),
                    a(str("exception"), arg)
                )
            ),
            b(str("block-content-type"),
                c(
                    str("activex"),
                    str("java-applet"),
                    str("exe"),
                    str("zip"),
                    str("http-cookie")
                )
            ),
            b(str("notification-options"),
                c(
                    b(str("type"),
                      (str("protocol-only") | str("message"))
                    ),
                    str("notify-mail-sender"),
                    str("no-notify-mail-sender"),
                    a(str("custom-message"), arg)
                )
            )
        )
    end

    rule(:content_filtering_traceoptions) do
        c(
            a(str("flag"), enum(str("basic") | str("detail") | str("all"))).as(:oneline)
        )
    end

    rule(:default_sbl_type) do
        c(
            str("sbl-default-server"),
            str("no-sbl-default-server"),
            b(str("spam-action"),
              (str("block") | str("tag-header") | str("tag-subject"))
            ),
            a(str("custom-tag-string"), arg)
        )
    end

    rule(:default_sophos_scan_options) do
        c(
            str("uri-check"),
            str("no-uri-check"),
            a(str("content-size-limit"), arg),
            a(str("timeout"), arg)
        )
    end

    rule(:default_webfilter_feature) do
        c(
            a(str("url-whitelist"), arg),
            a(str("url-blacklist"), arg),
            str("http-reassemble"),
            str("http-persist"),
            b(str("type"),
              (str("websense-redirect") | str("juniper-local") | str("juniper-enhanced") | str("web-filtering-none"))
            ),
            b(str("traceoptions"),
              web_filtering_traceoptions
            ),
            b(str("websense-redirect"),
              default_websense_type
            ),
            b(str("juniper-local"),
              default_juniper_local_type
            ),
            b(str("juniper-enhanced"),
              default_juniper_enhanced_type
            )
        )
    end

    rule(:default_juniper_enhanced_type) do
        c(
            b(str("cache"),
                c(
                    a(str("timeout"), arg),
                    a(str("size"), arg)
                )
            ),
            b(str("server"),
              juniper_enhanced_server
            ),
            b(str("reputation"),
                c(
                    a(str("reputation-very-safe"), arg),
                    a(str("reputation-moderately-safe"), arg),
                    a(str("reputation-fairly-safe"), arg),
                    a(str("reputation-suspicious"), arg)
                )
            ),
            a(str("base-filter"), arg),
            b(str("category"),
              juniper_enhanced_category_type
            ),
            b(str("site-reputation-action"),
              juniper_enhanced_site_reputation_setting
            ),
            b(str("default"),
              (str("permit") | str("block") | str("log-and-permit") | str("quarantine"))
            ),
            a(str("custom-block-message"), arg),
            a(str("quarantine-custom-message"), arg),
            b(str("fallback-settings"),
              web_filtering_fallback_setting
            ),
            a(str("timeout"), arg),
            str("no-safe-search"),
            b(str("block-message"),
              web_filtering_block_message
            ),
            b(str("quarantine-message"),
              web_filtering_quarantine_message
            )
        )
    end

    rule(:default_juniper_local_type) do
        c(
            b(str("default"),
              (str("permit") | str("block") | str("log-and-permit"))
            ),
            b(str("category"),
              custom_category_type
            ),
            a(str("custom-block-message"), arg),
            a(str("quarantine-custom-message"), arg),
            b(str("block-message"),
              web_filtering_block_message
            ),
            b(str("quarantine-message"),
              web_filtering_quarantine_message
            ),
            b(str("fallback-settings"),
              web_filtering_fallback_setting
            ),
            a(str("timeout"), arg)
        )
    end

    rule(:custom_category_type) do
      b(arg.as(:arg),
        c(
            b(str("action"),
              (str("permit") | str("log-and-permit") | str("block") | str("quarantine"))
            ),
            a(str("custom-message"), arg)
        )
      )
    end

    rule(:default_websense_type) do
        c(
            b(str("server"),
              server
            ),
            b(str("category"),
              custom_category_type
            ),
            a(str("custom-block-message"), arg),
            a(str("quarantine-custom-message"), arg),
            b(str("block-message"),
              web_filtering_block_message
            ),
            b(str("quarantine-message"),
              web_filtering_quarantine_message
            ),
            b(str("fallback-settings"),
              web_filtering_fallback_setting
            ),
            a(str("timeout"), arg),
            a(str("sockets"), arg),
            a(str("account"), arg)
        )
    end

    rule(:e2e_action_profile) do
      b(arg.as(:arg),
        c(
            str("preserve-trace-order"),
            str("record-pic-history"),
            b(str("event"),
              e2e_event
            ),
            b(str("module"),
              e2e_module
            )
        )
      )
    end

    rule(:e2e_event) do
      b((str("np-ingress") | str("np-egress") | str("mac-ingress") | str("mac-egress") | str("lbt") | str("pot") | str("jexec") | str("lt-enter") | str("lt-leave")).as(:arg),
        c(
            str("trace"),
            str("count"),
            str("packet-summary"),
            str("packet-dump")
        )
      )
    end

    rule(:e2e_module) do
      b((str("flow")).as(:arg),
        c(
            a(str("flag"), enum(str("all"))).as(:oneline)
        )
      )
    end

    rule(:end_to_end_debug_filter) do
      b(arg.as(:arg),
        c(
            b(str("action-profile"),
              (str("default") | arg)
            ),
            b(str("protocol"),
              (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
            ),
            b(str("source-prefix"),
              ipprefix
            ),
            b(str("destination-prefix"),
              ipprefix
            ),
            b(str("source-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("destination-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("interface"),
              interface_name
            )
        )
      )
    end

    rule(:extension_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), arg)
        )
      )
    end

    rule(:flow_filter_type) do
      b(arg.as(:arg),
        c(
            b(str("protocol"),
              (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
            ),
            b(str("source-prefix"),
              ipprefix
            ),
            b(str("destination-prefix"),
              ipprefix
            ),
            a(str("conn-tag"), arg),
            a(str("logical-system"), arg),
            b(str("source-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("destination-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("interface"),
              interface_name
            )
        )
      )
    end

    rule(:host_object) do
        c(
            a(str("port"), arg),
            a(str("routing-instance"), arg),
              ipaddr
        )
    end

    rule(:ids_option_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            str("alarm-without-drop"),
            b(str("match-direction"),
              (str("input") | str("output") | str("input-output"))
            ),
            b(str("icmp"),
                c(
                    b(str("ip-sweep"),
                        sc(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    str("fragment"),
                    str("large"),
                    b(str("flood"),
                        sc(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    str("ping-death"),
                    str("icmpv6-malformed")
                )
            ),
            b(str("ip"),
                c(
                    str("bad-option"),
                    str("record-route-option"),
                    str("timestamp-option"),
                    str("security-option"),
                    str("stream-option"),
                    str("spoofing"),
                    str("source-route-option"),
                    str("loose-source-route-option"),
                    str("strict-source-route-option"),
                    str("unknown-protocol"),
                    str("block-frag"),
                    str("tear-drop"),
                    b(str("ipv6-extension-header"),
                        c(
                            b(str("hop-by-hop-header"),
                                c(
                                    str("jumbo-payload-option"),
                                    str("router-alert-option"),
                                    str("quick-start-option"),
                                    str("CALIPSO-option"),
                                    str("SMF-DPD-option"),
                                    str("RPL-option"),
                                    b(a(str("user-defined-option-type"), arg),
                                        sc(
                                            b(str("to"),
                                                c(
                                                      arg
                                                )
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            str("routing-header"),
                            str("fragment-header"),
                            str("ESP-header"),
                            str("AH-header"),
                            str("no-next-header"),
                            b(str("destination-header"),
                                c(
                                    str("tunnel-encapsulation-limit-option"),
                                    str("home-address-option"),
                                    str("ILNP-nonce-option"),
                                    str("line-identification-option"),
                                    b(a(str("user-defined-option-type"), arg),
                                        sc(
                                            b(str("to"),
                                                c(
                                                      arg
                                                )
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            str("shim6-header"),
                            str("mobility-header"),
                            str("HIP-header"),
                            b(a(str("user-defined-header-type"), arg),
                                sc(
                                    b(str("to"),
                                        c(
                                              arg
                                        )
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("ipv6-extension-header-limit"), arg),
                    str("ipv6-malformed-header"),
                    b(str("tunnel"),
                        c(
                            str("bad-inner-header"),
                            b(str("gre"),
                                c(
                                    str("gre-6in4"),
                                    str("gre-4in6"),
                                    str("gre-6in6"),
                                    str("gre-4in4")
                                )
                            ),
                            b(str("ip-in-udp"),
                                c(
                                    str("teredo")
                                )
                            ),
                            b(str("ipip"),
                                c(
                                    str("ipip-6to4relay"),
                                    str("ipip-6in4"),
                                    str("ipip-4in6"),
                                    str("ipip-4in4"),
                                    str("ipip-6in6"),
                                    str("ipip-6over4"),
                                    str("isatap"),
                                    str("dslite")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("tcp"),
                c(
                    str("syn-fin"),
                    str("fin-no-ack"),
                    str("tcp-no-flag"),
                    str("syn-frag"),
                    b(str("port-scan"),
                        sc(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    b(str("syn-ack-ack-proxy"),
                        sc(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    b(str("syn-flood"),
                        c(
                            a(str("alarm-threshold"), arg),
                            a(str("attack-threshold"), arg),
                            a(str("source-threshold"), arg),
                            a(str("destination-threshold"), arg),
                            a(str("queue-size"), arg),
                            a(str("timeout"), arg),
                            b(a(str("white-list"), arg),
                                c(
                                    b(str("source-address"),
                                      ipprefix
                                    ),
                                    b(str("destination-address"),
                                      ipprefix
                                    )
                                )
                            )
                        )
                    ),
                    str("land"),
                    str("winnuke"),
                    b(str("tcp-sweep"),
                        sc(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("udp"),
                c(
                    b(str("flood"),
                        c(
                            a(str("threshold"), arg),
                            a(str("white-list"), arg)
                        )
                    ),
                    b(str("udp-sweep"),
                        sc(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    b(str("port-scan"),
                        sc(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("limit-session"),
                c(
                    a(str("source-ip-based"), arg),
                    a(str("destination-ip-based"), arg),
                    b(str("by-source"),
                        c(
                            a(str("maximum-sessions"), arg),
                            a(str("packet-rate"), arg),
                            a(str("session-rate"), arg),
                            b(str("by-protocol"),
                              by_protocol_object_type
                            )
                        )
                    ),
                    b(str("by-destination"),
                        c(
                            a(str("maximum-sessions"), arg),
                            a(str("packet-rate"), arg),
                            a(str("session-rate"), arg),
                            b(str("by-protocol"),
                              by_protocol_object_type
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:by_protocol_object_type) do
        c(
            b(str("tcp"),
                c(
                    a(str("maximum-sessions"), arg),
                    a(str("packet-rate"), arg),
                    a(str("session-rate"), arg)
                )
            ),
            b(str("udp"),
                c(
                    a(str("maximum-sessions"), arg),
                    a(str("packet-rate"), arg),
                    a(str("session-rate"), arg)
                )
            ),
            b(str("icmp"),
                c(
                    a(str("maximum-sessions"), arg),
                    a(str("packet-rate"), arg),
                    a(str("session-rate"), arg)
                )
            )
        )
    end

    rule(:ids_wlist_type) do
      b(arg.as(:arg),
        c(
            b(str("address"),
              ipprefix
            )
        )
      )
    end

    rule(:jsf_application_traffic_control_rule_set_type) do
        c(
            a(str("rule-set"), arg)
        )
    end

    rule(:juniper_enhanced_category_type) do
      b(arg.as(:arg),
        c(
            b(str("action"),
              (str("permit") | str("log-and-permit") | str("block") | str("quarantine"))
            ),
            a(str("custom-message"), arg)
        )
      )
    end

    rule(:juniper_enhanced_server) do
        c(
            a(str("host"), arg),
            a(str("port"), arg),
            a(str("proxy-profile"), arg),
            a(str("routing-instance"), arg)
        )
    end

    rule(:juniper_enhanced_site_reputation_setting) do
        c(
            b(str("very-safe"),
              (str("permit") | str("log-and-permit") | str("block") | str("quarantine"))
            ),
            b(str("moderately-safe"),
              (str("permit") | str("log-and-permit") | str("block") | str("quarantine"))
            ),
            b(str("fairly-safe"),
              (str("permit") | str("log-and-permit") | str("block") | str("quarantine"))
            ),
            b(str("suspicious"),
              (str("permit") | str("log-and-permit") | str("block") | str("quarantine"))
            ),
            b(str("harmful"),
              (str("permit") | str("log-and-permit") | str("block") | str("quarantine"))
            )
        )
    end

    rule(:logical_system_type) do
      b(arg.as(:arg),
        c(
            a(str("max-sessions"), arg)
        )
      )
    end

    rule(:mime_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), arg)
        )
      )
    end

    rule(:mirror_filter_type) do
      b(arg.as(:arg),
        c(
            b(str("protocol"),
              (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
            ),
            b(str("source-prefix"),
              ipprefix
            ),
            b(str("destination-prefix"),
              ipprefix
            ),
            b(str("source-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("destination-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("interface-in"),
              interface_name
            ),
            b(str("interface-out"),
              interface_name
            ),
            b(str("output"),
                c(
                    b(str("interface"),
                      interface_name
                    ),
                    a(str("destination-mac"), arg)
                )
            )
        )
      )
    end

    rule(:named_address_book_type) do
      b((str("global") | arg).as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("address"),
              address_type
            ),
            b(str("address-set"),
              address_set_type
            ),
            b(str("attach"),
                c(
                    a(str("zone"), arg)
                )
            )
        )
      )
    end

    rule(:address_set_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("address"), arg),
            a(str("address-set"), arg)
        )
      )
    end

    rule(:address_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            c(
              b(str("dns-name"),
                dns_name_type
              ),
              b(str("wildcard-address"),
                wildcard_address_type
              ),
              b(str("range-address"),
                range_address_type
              ),
                ipprefix
            )
        )
      )
    end

    rule(:dns_name_type) do
      b(arg.as(:arg),
        c(
            str("ipv4-only"),
            str("ipv6-only")
        )
      )
    end

    rule(:nat_object) do
        c(
            b(str("source"),
              ssg_source_nat_object
            ),
            b(str("destination"),
              ssg_destination_nat_object
            ),
            b(str("static"),
              ssg_static_nat_object
            ),
            b(str("proxy-arp"),
              ssg_proxy_arp_object
            ),
            b(str("proxy-ndp"),
              ssg_proxy_ndp_object
            ),
            b(str("natv6v4"),
                c(
                    str("no-v6-frag-header")
                )
            ),
            str("allow-overlapping-pools"),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("configuration") | str("flow") | str("routing-socket") | str("routing-protocol") | str("all") | str("source-nat-re") | str("source-nat-rt") | str("source-nat-pfe") | str("destination-nat-re") | str("destination-nat-rt") | str("destination-nat-pfe") | str("static-nat-re") | str("static-nat-rt") | str("static-nat-pfe") | str("nat-svc-set-re")),
                        sc(
                            str("syslog")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("pool"),
              nat_pool_object
            ),
            str("ipv6-multicast-interfaces"),
            str("allow-overlapping-nat-pools"),
            b(str("rule"),
              nat_rule_object
            ),
            b(str("port-forwarding"),
              pf_mapping
            ),
            str("rule-set")
        )
    end

    rule(:policy_object_type) do
        c(
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("configuration") | str("routing-socket") | str("compilation") | str("ipc") | str("rules") | str("lookup") | str("all"))).as(:oneline)
                )
            ),
            b(s(str("from-zone"), arg, str("to-zone"), arg),
                b(str("policy"), policy_type
                )
            ),
            b(str("global"),
                c(
                    b(str("policy"),
                      policy_type
                    )
                )
            ),
            b(str("default-policy"),
                c(
                    c(
                      str("permit-all"),
                      str("deny-all")
                    )
                )
            ),
            b(str("policy-rematch"),
                sc(
                    str("extensive")
                )
            ).as(:oneline),
            b(str("policy-stats"),
                c(
                    b(str("system-wide"),
                      (str("enable") | str("disable"))
                    )
                )
            ),
            b(str("pre-id-default-policy"),
                c(
                    b(str("then"),
                        c(
                            b(str("log"),
                              log_type
                            ),
                            b(str("session-timeout"),
                              session_timeout_type
                            )
                        )
                    )
                )
            ),
            b(a(str("stateful-firewall-rule"), arg),
                c(
                    b(str("match-direction"),
                      (str("input") | str("output") | str("input-output"))
                    ),
                    b(str("policy"),
                      policy_type
                    )
                )
            ),
            b(a(str("stateful-firewall-rule-set"), arg),
                c(
                    a(str("stateful-firewall-rule"), arg)
                )
            )
        )
    end

    rule(:log_type) do
        c(
            str("session-init"),
            str("session-close")
        )
    end

    rule(:policy_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("match"),
                c(
                    c(
                      b(str("source-address"),
                            (str("any") | str("any-ipv4") | str("any-ipv6") | arg)
                      )
                    ),
                    c(
                      b(str("destination-address"),
                            (str("any") | str("any-ipv4") | str("any-ipv6") | arg)
                      )
                    ),
                    str("source-address-excluded"),
                    str("destination-address-excluded"),
                    c(
                      b(str("application"),
                            (str("junos-defaults") | arg)
                      )
                    ),
                    c(
                      b(str("source-identity"),
                            (str("any") | str("authenticated-user") | str("unauthenticated-user") | str("unknown-user") | arg)
                      )
                    ),
                    c(
                      b(str("source-end-user-profile"),
                        match_source_end_user_profile_value
                      )
                    ),
                    c(
                      b(str("dynamic-application"),
                            (str("junos:UNKNOWN") | str("junos:unassigned") | str("any") | str("none") | arg)
                      )
                    ),
                    c(
                      b(str("from-zone"),
                            (str("any") | arg)
                      )
                    ),
                    c(
                      b(str("to-zone"),
                            (str("any") | arg)
                      )
                    )
                )
            ),
            b(str("then"),
                c(
                    c(
                      str("deny"),
                      b(str("reject"),
                          c(
                              a(str("profile"), arg),
                              b(str("ssl-proxy"),
                                  c(
                                      a(str("profile-name"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("permit"),
                          c(
                              b(str("tunnel"),
                                tunnel_type
                              ),
                              b(str("firewall-authentication"),
                                firewall_authentication_type
                              ),
                              b(str("destination-address"),
                                destination_nat_enable_type
                              ),
                              b(str("application-services"),
                                application_services_type
                              ),
                              b(str("tcp-options"),
                                  c(
                                      str("syn-check-required"),
                                      str("sequence-check-required"),
                                      a(str("initial-tcp-mss"), arg),
                                      a(str("reverse-tcp-mss"), arg),
                                      str("window-scale")
                                  )
                              ),
                              str("services-offload")
                          )
                      )
                    ),
                    b(str("log"),
                      log_type
                    ),
                    b(str("count"),
                      count_type
                    )
                )
            ),
            a(str("scheduler-name"), arg)
        )
      )
    end

    rule(:application_services_type) do
        c(
            a(str("gprs-gtp-profile"), arg),
            a(str("gprs-sctp-profile"), arg),
            str("idp"),
            a(str("idp-policy"), arg),
            b(str("ssl-proxy"),
                c(
                    a(str("profile-name"), arg)
                )
            ),
            b(str("uac-policy"),
                c(
                    a(str("captive-portal"), arg)
                )
            ),
            a(str("utm-policy"), arg),
            a(str("icap-redirect"), arg),
            b(str("application-firewall"),
              jsf_service_rule_set_type
            ),
            b(str("application-traffic-control"),
              jsf_application_traffic_control_rule_set_type
            ),
            c(
              str("redirect-wx"),
              str("reverse-redirect-wx")
            ),
            a(str("security-intelligence-policy"), arg),
            a(str("advanced-anti-malware-policy"), arg)
        )
    end

    rule(:count_type) do

    end

    rule(:destination_nat_enable_type) do
        c(
            c(
              str("drop-translated"),
              str("drop-untranslated")
            )
        )
    end

    rule(:firewall_authentication_type) do
        c(
            c(
              b(str("pass-through"),
                  c(
                      a(str("access-profile"), arg),
                      a(str("client-match"), arg),
                      str("web-redirect"),
                      str("web-redirect-to-https"),
                      a(str("ssl-termination-profile"), arg),
                      str("auth-only-browser"),
                      a(str("auth-user-agent"), arg)
                  )
              ),
              b(str("web-authentication"),
                  c(
                      a(str("client-match"), arg)
                  )
              ),
              b(str("user-firewall"),
                  c(
                      a(str("access-profile"), arg),
                      str("web-redirect"),
                      str("web-redirect-to-https"),
                      a(str("ssl-termination-profile"), arg),
                      str("auth-only-browser"),
                      a(str("auth-user-agent"), arg),
                      a(str("domain"), arg)
                  )
              )
            ),
            str("push-to-identity-management")
        )
    end

    rule(:jsf_service_rule_set_type) do
        c(
            a(str("rule-set"), arg)
        )
    end

    rule(:match_source_end_user_profile_value) do
        c(
            arg
        )
    end

    rule(:profile_setting) do
      b(arg.as(:arg),
        c(
            b(str("anti-virus"),
                c(
                    a(str("http-profile"), arg),
                    b(str("ftp"),
                        c(
                            a(str("upload-profile"), arg),
                            a(str("download-profile"), arg)
                        )
                    ),
                    a(str("smtp-profile"), arg),
                    a(str("pop3-profile"), arg),
                    a(str("imap-profile"), arg)
                )
            ),
            b(str("content-filtering"),
                c(
                    a(str("http-profile"), arg),
                    b(str("ftp"),
                        c(
                            a(str("upload-profile"), arg),
                            a(str("download-profile"), arg)
                        )
                    ),
                    a(str("smtp-profile"), arg),
                    a(str("pop3-profile"), arg),
                    a(str("imap-profile"), arg)
                )
            ),
            b(str("web-filtering"),
                c(
                    a(str("http-profile"), arg)
                )
            ),
            b(str("anti-spam"),
                c(
                    a(str("smtp-profile"), arg)
                )
            ),
            b(str("traffic-options"),
                c(
                    b(str("sessions-per-client"),
                        c(
                            a(str("limit"), arg),
                            b(str("over-limit"),
                              (str("log-and-permit") | str("block"))
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:ragw_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sc(
                      arg,
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            b(str("level"),
              (str("brief") | str("detail") | str("extensive") | str("verbose"))
            ),
            a(str("flag"), enum(str("configuration") | str("tunnel") | str("session") | str("all"))).as(:oneline)
        )
    end

    rule(:range_address_type) do
      b(arg.as(:arg),
        c(
            b(str("to"),
                c(
                      ipv4addr
                )
            )
        )
      )
    end

    rule(:sbl_type) do
        c(
            b(a(str("profile"), arg),
                c(
                    str("sbl-default-server"),
                    str("no-sbl-default-server"),
                    b(str("spam-action"),
                      (str("block") | str("tag-header") | str("tag-subject"))
                    ),
                    a(str("custom-tag-string"), arg),
                    a(str("address-whitelist"), arg),
                    a(str("address-blacklist"), arg)
                )
            )
        )
    end

    rule(:secure_wire_type) do
      b(arg.as(:arg),
        c(
            b(str("interface"),
              interface_unit
            )
        )
      )
    end

    rule(:security_ipsec_policies) do
        c(
            b(str("from-zone"),
              security_ipsec_policy
            )
        )
    end

    rule(:security_ipsec_policy) do
        s(
                arg,
          a(str("to-zone"), arg),
          c(
            a(str("ipsec-group-vpn"), arg)
          )
        )
    end

    rule(:ipsec_traceoptions) do
        c(
            a(str("flag"), enum(str("packet-processing") | str("packet-drops") | str("security-associations") | str("next-hop-tunnel-binding") | str("all"))).as(:oneline)
        )
    end

    rule(:ipsec_vpn_monitor) do
        c(
            a(str("interval"), arg),
            a(str("threshold"), arg)
        )
    end

    rule(:ipsec_vpn_template) do
      b(arg.as(:arg),
        c(
            b(str("bind-interface"),
              interface_name
            ),
            b(str("df-bit"),
              (str("clear") | str("set") | str("copy"))
            ),
            b(str("multi-sa"),
                c(
                    c(
                      a(str("forwarding-class"), arg)
                    )
                )
            ),
            str("copy-outer-dscp"),
            b(str("vpn-monitor"),
              ipsec_template_monitor
            ),
            c(
              b(str("manual"),
                  c(
                      b(str("gateway"),
                        hostname
                      ),
                      b(str("external-interface"),
                        interface_unit
                      ),
                      b(str("protocol"),
                        (str("ah") | str("esp"))
                      ),
                      a(str("spi"), arg),
                      b(str("authentication"),
                          c(
                              b(str("algorithm"),
                                (str("hmac-md5-96") | str("hmac-sha1-96") | str("hmac-sha-256-128") | str("hmac-sha-256-96"))
                              ),
                              b(str("key"),
                                  sc(
                                      c(
                                        a(str("ascii-text"), arg),
                                        a(str("hexadecimal"), arg)
                                      )
                                  )
                              ).as(:oneline)
                          )
                      ),
                      b(str("encryption"),
                          c(
                              b(str("algorithm"),
                                (str("des-cbc") | str("3des-cbc") | str("aes-128-cbc") | str("aes-192-cbc") | str("aes-256-cbc") | str("aes-128-gcm") | str("aes-256-gcm"))
                              ),
                              b(str("key"),
                                  sc(
                                      c(
                                        a(str("ascii-text"), arg),
                                        a(str("hexadecimal"), arg)
                                      )
                                  )
                              ).as(:oneline)
                          )
                      )
                  )
              ),
              b(str("ike"),
                  c(
                      a(str("gateway"), arg),
                      a(str("idle-time"), arg),
                      str("no-anti-replay"),
                      b(str("proxy-identity"),
                        ipsec_template_proxy_id
                      ),
                      a(str("ipsec-policy"), arg),
                      a(str("install-interval"), arg)
                  )
              )
            ),
            b(a(str("traffic-selector"), arg),
                c(
                    b(str("local-ip"),
                      ipprefix_mandatory
                    ),
                    b(str("remote-ip"),
                      ipprefix_mandatory
                    )
                )
            ),
            b(str("establish-tunnels"),
              (str("immediately") | str("on-traffic"))
            ),
            str("passive-mode-tunneling"),
            a(str("match-direction"), arg),
            a(str("tunnel-mtu"), arg),
            b(str("udp-encapsulate"),
                sc(
                    a(str("dest-port"), arg)
                )
            ).as(:oneline)
        )
      )
    end

    rule(:ipsec_template_monitor) do
        c(
            str("optimized"),
            b(str("source-interface"),
              interface_unit
            ),
            b(str("destination-ip"),
              ipaddr
            ),
            b(str("verify-path"),
                c(
                    b(str("destination-ip"),
                      ipaddr
                    ),
                    a(str("packet-size"), arg)
                )
            )
        )
    end

    rule(:ipsec_template_proxy_id) do
        c(
            b(str("local"),
              ipprefix_mandatory
            ),
            b(str("remote"),
              ipprefix_mandatory
            ),
            a(str("service"), arg)
        )
    end

    rule(:security_zone_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            str("tcp-rst"),
            b(str("address-book"),
              address_book_type
            ),
            a(str("screen"), arg),
            b(str("host-inbound-traffic"),
              zone_host_inbound_traffic_t
            ),
            b(str("interfaces"),
              zone_interface_list_type
            ),
            str("application-tracking"),
            str("source-identity-log"),
            b(str("advance-policy-based-routing-profile"),
                c(
                      arg
                )
            ),
            str("enable-reverse-reroute")
        )
      )
    end

    rule(:address_book_type) do
        c(
            b(str("address"),
              address_type
            ),
            b(str("address-set"),
              address_set_type
            )
        )
    end

    rule(:server) do
        c(
            a(str("host"), arg),
            a(str("port"), arg),
            a(str("routing-instance"), arg)
        )
    end

    rule(:session_timeout_type) do
        c(
            a(str("tcp"), arg),
            a(str("udp"), arg),
            a(str("ospf"), arg),
            a(str("icmp6"), arg),
            a(str("icmp"), arg),
            a(str("others"), arg)
        )
    end

    rule(:sla_policy_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("match"),
                c(
                    c(
                      b(str("source-address"),
                            (str("any") | str("any-ipv4") | str("any-ipv6") | arg)
                      )
                    ),
                    c(
                      b(str("destination-address"),
                            (str("any") | str("any-ipv4") | str("any-ipv6") | arg)
                      )
                    ),
                    str("source-address-excluded"),
                    str("destination-address-excluded"),
                    c(
                      a(str("application"), arg)
                    )
                )
            ),
            b(str("then"),
                c(
                    c(
                      b(str("application-services"),
                        sla_application_services_type
                      )
                    )
                )
            )
        )
      )
    end

    rule(:sla_application_services_type) do
        c(
            a(str("advance-policy-based-routing-profile"), arg)
        )
    end

    rule(:softwires_object) do
        c(
            b(str("softwire-name"),
              softwire_option_type
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sc(
                              arg,
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable"),
                            b(str("match"),
                              regular_expression
                            )
                        )
                    ).as(:oneline),
                    a(str("flag"), enum(str("configuration") | str("flow") | str("all"))).as(:oneline)
                )
            ),
            b(str("rule-set"),
              sw_rule_set_object
            )
        )
    end

    rule(:softwire_option_type) do
      b(arg.as(:arg),
        c(
            b(str("softwire-concentrator"),
              ipaddr
            ),
            b(str("softwire-type"),
              (str("IPv4-in-IPv6") | str("v6rd"))
            ),
            b(str("ipv4-prefix"),
              ipv4prefix
            ),
            b(str("v6rd-prefix"),
              ipv6prefix
            ),
            a(str("mtu-v4"), arg)
        )
      )
    end

    rule(:sophos_fallback_settings) do
        c(
            b(str("default"),
              (str("permit") | str("log-and-permit") | str("block"))
            ),
            b(str("content-size"),
              (str("permit") | str("log-and-permit") | str("block"))
            ),
            b(str("engine-not-ready"),
              (str("permit") | str("log-and-permit") | str("block"))
            ),
            b(str("timeout"),
              (str("permit") | str("log-and-permit") | str("block"))
            ),
            b(str("out-of-resources"),
              (str("permit") | str("log-and-permit") | str("block"))
            ),
            b(str("too-many-requests"),
              (str("permit") | str("log-and-permit") | str("block"))
            )
        )
    end

    rule(:sophos_scan_options) do
        c(
            str("uri-check"),
            str("no-uri-check"),
            a(str("content-size-limit"), arg),
            a(str("timeout"), arg)
        )
    end

    rule(:ssg_destination_nat_object) do
        c(
            b(a(str("pool"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("routing-instance"),
                        c(
                            c(
                              str("default"),
                                arg
                            )
                        )
                    ),
                    b(str("address"),
                        sc(
                            c(
                              b(str("to"),
                                  c(
                                        ipprefix
                                  )
                              ),
                              a(str("port"), arg)
                            ),
                              ipprefix
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("port-forwarding"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("destined-port"),
                        s(
                                arg,
                          a(str("translated-port"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("rule-set"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("from"),
                        sc(
                            c(
                              b(str("routing-instance"),
                                    (str("default") | arg)
                              ),
                              a(str("zone"), arg),
                              b(str("interface"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("rule"),
                      dest_nat_rule_object
                    ),
                    b(str("match-direction"),
                      (str("input") | str("output"))
                    )
                )
            )
        )
    end

    rule(:dest_nat_rule_object) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("match"),
                c(
                    b(str("source-address"),
                      ipprefix
                    ),
                    a(str("source-address-name"), arg),
                    c(
                      b(str("destination-address"),
                          sc(
                                ipprefix
                          )
                      ).as(:oneline),
                      b(str("destination-address-name"),
                          sc(
                                arg
                          )
                      ).as(:oneline)
                    ),
                    b(a(str("destination-port"), arg),
                        sc(
                            b(str("to"),
                                c(
                                    arg
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("protocol"),
                          (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
                    ),
                    a(str("application"), arg)
                )
            ),
            b(str("then"),
                c(
                    b(str("destination-nat"),
                        c(
                            c(
                              str("off"),
                              b(str("pool"),
                                  c(
                                        arg
                                  )
                              ),
                              b(str("destination-prefix"),
                                ipprefix_only
                              )
                            ),
                            b(str("port-forwarding-mappings"),
                                c(
                                      arg
                                )
                            ),
                            b(str("rule-session-count-alarm"),
                              nat_rule_session_count_alarm_object
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:nat_rule_session_count_alarm_object) do
        c(
            a(str("raise-threshold"), arg),
            a(str("clear-threshold"), arg)
        ).as(:oneline)
    end

    rule(:ssg_proxy_arp_object) do
        c(
            b(str("interface"),
              ssg_interface_object
            )
        )
    end

    rule(:ssg_interface_object) do
      b(arg.as(:arg),
        c(
            b(a(str("address"), arg),
                sc(
                    b(str("to"),
                        c(
                              ipv4prefix
                        )
                    )
                )
            ).as(:oneline)
        )
      )
    end

    rule(:ssg_proxy_ndp_object) do
        c(
            b(str("interface"),
              ssg_proxy_ndp_interface_object
            )
        )
    end

    rule(:ssg_proxy_ndp_interface_object) do
      b(arg.as(:arg),
        c(
            b(a(str("address"), arg),
                sc(
                    b(str("to"),
                        c(
                              ipv6addr
                        )
                    )
                )
            ).as(:oneline)
        )
      )
    end

    rule(:ssg_source_nat_object) do
        c(
            b(a(str("pool"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("routing-instance"),
                        c(
                              arg
                        )
                    ),
                    b(a(str("address"), arg),
                        sc(
                            b(str("to"),
                                c(
                                      ipprefix
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("host-address-base"),
                        sc(
                              ipprefix
                        )
                    ).as(:oneline),
                    b(str("port"),
                        c(
                            c(
                              str("no-translation"),
                              b(str("range"),
                                  ca(
                                      b(str("to"),
                                          c(
                                                arg
                                          )
                                      ),
                                      b(str("twin-port"),
                                          ca(
                                              b(str("to"),
                                                  c(
                                                        arg
                                                  )
                                              )
                                          )
                                      )
                                  )
                              )
                            ),
                            a(str("port-overloading-factor"), arg),
                            b(str("block-allocation"),
                              block_allocation_object
                            ),
                            b(str("deterministic"),
                              deterministic_object
                            ),
                            str("preserve-parity"),
                            str("preserve-range"),
                            b(str("automatic"),
                                c(
                                    c(
                                      str("random-allocation"),
                                      str("round-robin")
                                    )
                                )
                            )
                        )
                    ),
                    b(str("overflow-pool"),
                        sc(
                            ca(
                              str("interface")
                            )
                        )
                    ).as(:oneline),
                    str("address-shared"),
                    b(str("address-pooling"),
                        sc(
                            c(
                              str("paired"),
                              str("no-paired")
                            )
                        )
                    ).as(:oneline),
                    b(str("address-persistent"),
                        sc(
                            b(str("subscriber"),
                                sc(
                                    a(str("ipv6-prefix-length"), arg)
                                )
                            ).as(:oneline)
                        )
                    ).as(:oneline),
                    b(str("pool-utilization-alarm"),
                      source_nat_pool_utilization_alarm_object
                    ).as(:oneline),
                    a(str("ei-mapping-timeout"), arg),
                    a(str("mapping-timeout"), arg),
                    a(str("limit-ports-per-host"), arg)
                )
            ),
            str("address-persistent"),
            str("session-persistence-scan"),
            a(str("session-drop-hold-down"), arg),
            b(str("pool-utilization-alarm"),
              source_nat_pool_utilization_alarm_object
            ).as(:oneline),
            b(str("port-randomization"),
                sc(
                      (str("disable"))
                )
            ).as(:oneline),
            str("port-round-robin").as(:oneline),
            str("port-scaling-enlargement"),
            str("pool-distribution"),
            b(str("pool-default-port-range"),
                sc(
                      arg,
                    b(str("to"),
                        c(
                              arg
                        )
                    )
                )
            ).as(:oneline),
            b(str("pool-default-twin-port-range"),
                sc(
                      arg,
                    b(str("to"),
                        c(
                              arg
                        )
                    )
                )
            ).as(:oneline),
            b(str("interface"),
                c(
                    c(
                      b(str("port-overloading"),
                          sc(
                              str("off")
                          )
                      ).as(:oneline),
                      a(str("port-overloading-factor"), arg)
                    )
                )
            ),
            b(a(str("rule-set"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("from"),
                        sc(
                            c(
                              b(str("routing-instance"),
                                    (str("default") | arg)
                              ),
                              a(str("zone"), arg),
                              b(str("interface"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("to"),
                        sc(
                            c(
                              b(str("routing-instance"),
                                    (str("default") | arg)
                              ),
                              a(str("zone"), arg),
                              b(str("interface"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("rule"),
                      src_nat_rule_object
                    ),
                    b(str("match-direction"),
                      (str("input") | str("output"))
                    )
                )
            )
        )
    end

    rule(:block_allocation_object) do
        c(
            a(str("block-size"), arg),
            a(str("maximum-blocks-per-host"), arg),
            a(str("active-block-timeout"), arg),
            a(str("interim-logging-interval"), arg),
            a(str("last-block-recycle-timeout"), arg),
            b(str("log"),
                sc(
                      (str("disable"))
                )
            ).as(:oneline)
        )
    end

    rule(:deterministic_object) do
        c(
            a(str("block-size"), arg),
            a(str("det-nat-configuration-log-interval"), arg),
            b(str("host"),
                sc(
                    b(str("address"),
                      ipprefix
                    ),
                    a(str("address-name"), arg)
                )
            ).as(:oneline),
            str("include-boundary-addresses")
        )
    end

    rule(:source_nat_pool_utilization_alarm_object) do
        c(
            a(str("raise-threshold"), arg),
            a(str("clear-threshold"), arg)
        ).as(:oneline)
    end

    rule(:src_nat_rule_object) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("match"),
                c(
                    b(str("source-address"),
                      ipprefix
                    ),
                    a(str("source-address-name"), arg),
                    b(a(str("source-port"), arg),
                        sc(
                            b(str("to"),
                                c(
                                    arg
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("destination-address"),
                      ipprefix
                    ),
                    a(str("destination-address-name"), arg),
                    b(a(str("destination-port"), arg),
                        sc(
                            b(str("to"),
                                c(
                                    arg
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("protocol"),
                          (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
                    ),
                    a(str("application"), arg)
                )
            ),
            b(str("then"),
                c(
                    b(str("source-nat"),
                        c(
                            c(
                              str("off"),
                              b(str("pool"),
                                  ca(
                                      b(str("persistent-nat"),
                                        persistent_nat_object
                                      )
                                  )
                              ),
                              b(str("interface"),
                                  c(
                                      b(str("persistent-nat"),
                                        persistent_nat_object
                                      )
                                  )
                              )
                            ),
                            b(str("clat-prefix"),
                              ipprefix_only
                            ),
                            b(str("rule-session-count-alarm"),
                              nat_rule_session_count_alarm_object
                            ).as(:oneline),
                            b(str("mapping-type"),
                                sc(
                                    str("endpoint-independent")
                                )
                            ).as(:oneline),
                            b(str("secure-nat-mapping"),
                                sc(
                                    a(str("eif-flow-limit"), arg),
                                    b(str("mapping-refresh"),
                                        sc(
                                            c(
                                              str("inbound"),
                                              str("outbound"),
                                              str("inbound-outbound")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ).as(:oneline),
                            b(str("filtering-type"),
                                c(
                                    b(str("endpoint-independent"),
                                        c(
                                            b(a(str("prefix-list"), arg),
                                                sc(
                                                    str("except")
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:persistent_nat_object) do
        c(
            b(str("permit"),
                sc(
                    c(
                      str("any-remote-host"),
                      str("target-host"),
                      str("target-host-port")
                    )
                )
            ).as(:oneline),
            str("address-mapping"),
            a(str("inactivity-timeout"), arg),
            a(str("max-session-number"), arg)
        )
    end

    rule(:ssg_static_nat_object) do
        c(
            b(a(str("rule-set"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("from"),
                        sc(
                            c(
                              b(str("routing-instance"),
                                    (str("default") | arg)
                              ),
                              a(str("zone"), arg),
                              b(str("interface"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("rule"),
                      static_nat_rule_object
                    )
                )
            )
        )
    end

    rule(:static_nat_rule_object) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("match"),
                c(
                    b(str("source-address"),
                      ipprefix
                    ),
                    a(str("source-address-name"), arg),
                    b(a(str("source-port"), arg),
                        sc(
                            b(str("to"),
                                c(
                                    arg
                                )
                            )
                        )
                    ).as(:oneline),
                    c(
                      b(str("destination-address"),
                          sc(
                                ipprefix
                          )
                      ).as(:oneline),
                      b(str("destination-address-name"),
                          sc(
                                arg
                          )
                      ).as(:oneline)
                    ),
                    b(str("destination-port"),
                        sc(
                            arg,
                            b(str("to"),
                                c(
                                    arg
                                )
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("then"),
                c(
                    b(str("static-nat"),
                        c(
                            c(
                              b(str("inet"),
                                  c(
                                      b(str("routing-instance"),
                                        (str("default") | arg)
                                      )
                                  )
                              ),
                              b(str("prefix"),
                                  c(
                                      b(str("mapped-port"),
                                        static_nat_rule_mapped_port_object
                                      ).as(:oneline),
                                      b(str("routing-instance"),
                                        (str("default") | arg)
                                      ),
                                        ipprefix
                                  )
                              ),
                              b(str("prefix-name"),
                                  ca(
                                      b(str("mapped-port"),
                                        static_nat_rule_mapped_port_object
                                      ).as(:oneline),
                                      b(str("routing-instance"),
                                        (str("default") | arg)
                                      )
                                  )
                              ),
                              b(str("nptv6-prefix"),
                                  c(
                                      b(str("routing-instance"),
                                        (str("default") | arg)
                                      ),
                                        ipprefix
                                  )
                              ),
                              b(str("nptv6-prefix-name"),
                                  ca(
                                      b(str("routing-instance"),
                                        (str("default") | arg)
                                      )
                                  )
                              )
                            ),
                            b(str("rule-session-count-alarm"),
                              nat_rule_session_count_alarm_object
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:static_nat_rule_mapped_port_object) do
        ca(
            b(str("to"),
                c(
                    arg
                )
            )
        ).as(:oneline)
    end

    rule(:sw_rule_set_object) do
      b(arg.as(:arg),
        c(
            b(a(str("rule"), arg),
                c(
                    b(str("then"),
                        c(
                            c(
                              a(str("v6rd"), arg)
                            )
                        )
                    )
                )
            ),
            b(str("match-direction"),
              (str("input") | str("output"))
            )
        )
      )
    end

    rule(:tunnel_type) do
        c(
            c(
              a(str("ipsec-vpn"), arg),
              a(str("ipsec-group-vpn"), arg)
            ),
            a(str("pair-policy"), arg)
        )
    end

    rule(:url_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), arg)
        )
      )
    end

    rule(:utm_apppxy_traceoptions) do
        c(
            a(str("flag"), enum(str("abort") | str("application-objects") | str("utm-realtime") | str("anti-virus") | str("basic") | str("buffer") | str("detail") | str("ftp-data") | str("ftp-control") | str("http") | str("imap") | str("memory") | str("parser") | str("pfe") | str("pop3") | str("queue") | str("smtp") | str("tcp") | str("timer") | str("connection-rating") | str("mime") | str("regex-engine") | str("sophos-anti-virus") | str("all"))).as(:oneline)
        )
    end

    rule(:utm_ipc_traceoptions) do
        c(
            a(str("flag"), enum(str("basic") | str("detail") | str("connection-manager") | str("connection-status") | str("pfe") | str("utm-realtime") | str("all"))).as(:oneline)
        )
    end

    rule(:utm_traceoptions) do
        c(
            a(str("flag"), enum(str("cli") | str("daemon") | str("ipc") | str("pfe") | str("all"))).as(:oneline)
        )
    end

    rule(:web_filtering_block_message) do
        c(
            b(str("type"),
              (str("custom-redirect-url"))
            ),
            a(str("url"), arg)
        )
    end

    rule(:web_filtering_fallback_setting) do
        c(
            b(str("default"),
              (str("log-and-permit") | str("block"))
            ),
            b(str("server-connectivity"),
              (str("log-and-permit") | str("block"))
            ),
            b(str("timeout"),
              (str("log-and-permit") | str("block"))
            ),
            b(str("too-many-requests"),
              (str("log-and-permit") | str("block"))
            )
        )
    end

    rule(:web_filtering_quarantine_message) do
        c(
            b(str("type"),
              (str("custom-redirect-url"))
            ),
            a(str("url"), arg)
        )
    end

    rule(:web_filtering_traceoptions) do
        c(
            a(str("flag"), enum(str("basic") | str("session-manager") | str("heartbeat") | str("packet") | str("profile") | str("requests") | str("response") | str("socket") | str("timer") | str("ipc") | str("cache") | str("enhanced") | str("all"))).as(:oneline)
        )
    end

    rule(:webfilter_feature) do
        c(
            b(str("surf-control-integrated"),
              surf_control_integrated_type
            ),
            b(str("websense-redirect"),
              websense_type
            ),
            b(str("juniper-local"),
              juniper_local_type
            ),
            b(str("juniper-enhanced"),
              juniper_enhanced_type
            )
        )
    end

    rule(:juniper_enhanced_type) do
        c(
            b(a(str("profile"), arg),
                c(
                    a(str("base-filter"), arg),
                    b(str("category"),
                      juniper_enhanced_category_type
                    ),
                    b(str("site-reputation-action"),
                      juniper_enhanced_site_reputation_setting
                    ),
                    b(str("default"),
                      (str("permit") | str("block") | str("log-and-permit") | str("quarantine"))
                    ),
                    a(str("custom-block-message"), arg),
                    a(str("quarantine-custom-message"), arg),
                    b(str("fallback-settings"),
                      web_filtering_fallback_setting
                    ),
                    a(str("timeout"), arg),
                    str("no-safe-search"),
                    b(str("block-message"),
                      web_filtering_block_message
                    ),
                    b(str("quarantine-message"),
                      web_filtering_quarantine_message
                    )
                )
            )
        )
    end

    rule(:juniper_local_type) do
        c(
            b(a(str("profile"), arg),
                c(
                    b(str("default"),
                      (str("permit") | str("block") | str("log-and-permit"))
                    ),
                    b(str("category"),
                      custom_category_type
                    ),
                    a(str("custom-block-message"), arg),
                    a(str("quarantine-custom-message"), arg),
                    b(str("block-message"),
                      web_filtering_block_message
                    ),
                    b(str("quarantine-message"),
                      web_filtering_quarantine_message
                    ),
                    b(str("fallback-settings"),
                      web_filtering_fallback_setting
                    ),
                    a(str("timeout"), arg)
                )
            )
        )
    end

    rule(:surf_control_integrated_type) do
        c(
            b(str("cache"),
                c(
                    a(str("timeout"), arg),
                    a(str("size"), arg)
                )
            ),
            b(str("server"),
              server
            ),
            b(a(str("profile"), arg),
                c(
                    b(str("category"),
                      surf_control_integrated_category_type
                    ),
                    b(str("default"),
                      (str("permit") | str("block") | str("log-and-permit"))
                    ),
                    a(str("custom-block-message"), arg),
                    b(str("fallback-settings"),
                      web_filtering_fallback_setting
                    ),
                    a(str("timeout"), arg)
                )
            )
        )
    end

    rule(:surf_control_integrated_category_type) do
      b(arg.as(:arg),
        c(
            b(str("action"),
              (str("permit") | str("block") | str("log-and-permit"))
            )
        )
      )
    end

    rule(:websense_type) do
        c(
            b(a(str("profile"), arg),
                c(
                    b(str("server"),
                      server
                    ),
                    b(str("category"),
                      custom_category_type
                    ),
                    a(str("custom-block-message"), arg),
                    a(str("quarantine-custom-message"), arg),
                    b(str("block-message"),
                      web_filtering_block_message
                    ),
                    b(str("quarantine-message"),
                      web_filtering_quarantine_message
                    ),
                    b(str("fallback-settings"),
                      web_filtering_fallback_setting
                    ),
                    a(str("timeout"), arg),
                    a(str("sockets"), arg),
                    a(str("account"), arg)
                )
            )
        )
    end

    rule(:wildcard_address_type) do
      arg.as(:arg)
    end

    rule(:zone_interface_list_type) do
      b(arg.as(:arg),
        c(
            b(str("host-inbound-traffic"),
              interface_host_inbound_traffic_t
            )
        )
      )
    end

    rule(:interface_host_inbound_traffic_t) do
        c(
            b(str("system-services"),
              interface_system_services_object_type
            ),
            b(str("protocols"),
              host_inbound_protocols_object_type
            )
        )
    end

    rule(:host_inbound_protocols_object_type) do
      b(enum((str("all") | str("bfd") | str("bgp") | str("dvmrp") | str("igmp") | str("ldp") | str("msdp") | str("ndp") | str("nhrp") | str("ospf3") | str("ospf") | str("pgm") | str("pim") | str("rip") | str("ripng") | str("router-discovery") | str("rsvp") | str("sap") | str("vrrp"))).as(:arg),
        c(
            str("except")
        )
      )
    end

    rule(:interface_system_services_object_type) do
      b(enum((str("all") | str("bootp") | str("dhcp") | str("dhcpv6") | str("dns") | str("finger") | str("ftp") | str("ident-reset") | str("https") | str("http") | str("ike") | str("netconf") | str("ping") | str("rlogin") | str("reverse-telnet") | str("reverse-ssh") | str("rpm") | str("rsh") | str("snmp") | str("snmp-trap") | str("ssh") | str("telnet") | str("traceroute") | str("xnm-ssl") | str("xnm-clear-text") | str("tftp") | str("lsping") | str("ntp") | str("sip") | str("r2cp") | str("webapi-clear-text") | str("webapi-ssl") | str("tcp-encap") | str("appqoe") | str("any-service"))).as(:arg),
        c(
            str("except")
        )
      )
    end

    rule(:zone_host_inbound_traffic_t) do
        c(
            b(str("system-services"),
              zone_system_services_object_type
            ),
            b(str("protocols"),
              host_inbound_protocols_object_type
            )
        )
    end

    rule(:zone_system_services_object_type) do
      b(enum((str("all") | str("bootp") | str("dhcp") | str("dhcpv6") | str("dns") | str("finger") | str("ftp") | str("ident-reset") | str("https") | str("http") | str("ike") | str("netconf") | str("ping") | str("rlogin") | str("reverse-telnet") | str("reverse-ssh") | str("rpm") | str("rsh") | str("snmp") | str("snmp-trap") | str("ssh") | str("telnet") | str("traceroute") | str("xnm-ssl") | str("xnm-clear-text") | str("tftp") | str("lsping") | str("ntp") | str("sip") | str("r2cp") | str("webapi-clear-text") | str("webapi-ssl") | str("tcp-encap") | str("appqoe") | str("any-service"))).as(:arg),
        c(
            str("except")
        )
      )
    end

    rule(:application_object) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("term"),
              term_object
            ),
            b(str("application-protocol"),
              (str("bootp") | str("dce-rpc") | str("dce-rpc-portmap") | str("dns") | str("exec") | str("ftp") | str("ftp-data") | str("gprs-gtp-c") | str("gprs-gtp-u") | str("gprs-gtp-v0") | str("gprs-sctp") | str("h323") | str("icmpv6") | str("icmp") | str("ignore") | str("iiop") | str("ike-esp-nat") | str("ip") | str("login") | str("mgcp-ca") | str("mgcp-ua") | str("ms-rpc") | str("netbios") | str("netshow") | str("none") | str("pptp") | str("q931") | str("ras") | str("realaudio") | str("rpc") | str("rpc-portmap") | str("rsh") | str("rtsp") | str("sccp") | str("sip") | str("shell") | str("snmp") | str("sqlnet") | str("sqlnet-v2") | str("sun-rpc") | str("talk") | str("tftp") | str("traceroute") | str("https") | str("winframe") | str("http") | str("imap") | str("smtp") | str("ssh") | str("telnet") | str("twamp"))
            ),
            b(str("protocol"),
              (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
            ),
            b(str("source-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("destination-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            a(str("ether-type"), arg),
            a(str("snmp-command"), arg),
            b(str("icmp-type"),
              (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
            ),
            b(str("icmp6-type"),
              (str("echo-request") | str("echo-reply") | str("destination-unreachable") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("packet-too-big") | str("membership-query") | str("membership-report") | str("membership-termination") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | arg)
            ),
            b(str("icmp-code"),
              (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
            ),
            b(str("icmp6-code"),
              (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
            ),
            a(str("ttl-threshold"), arg),
            a(str("rpc-program-number"), arg),
            a(str("uuid"), arg),
            b(str("inactivity-timeout"),
              (str("never") | arg)
            ),
            a(str("gate-timeout"), arg),
            a(str("child-inactivity-timeout"), arg),
            str("learn-sip-register"),
            a(str("sip-call-hold-timeout"), arg),
            c(
              str("do-not-translate-AAAA-query-to-A-query"),
              str("do-not-translate-A-query-to-AAAA-query")
            )
        )
      )
    end

    rule(:term_object) do
      b(arg.as(:arg),
        sc(
            b(str("alg"),
              (str("bootp") | str("dce-rpc") | str("dce-rpc-portmap") | str("dns") | str("exec") | str("ftp") | str("ftp-data") | str("gprs-gtp-c") | str("gprs-gtp-u") | str("gprs-gtp-v0") | str("gprs-sctp") | str("h323") | str("icmpv6") | str("icmp") | str("ignore") | str("iiop") | str("ike-esp-nat") | str("ip") | str("login") | str("mgcp-ca") | str("mgcp-ua") | str("ms-rpc") | str("netbios") | str("netshow") | str("none") | str("pptp") | str("q931") | str("ras") | str("realaudio") | str("rpc") | str("rpc-portmap") | str("rsh") | str("rtsp") | str("sccp") | str("sip") | str("shell") | str("snmp") | str("sqlnet") | str("sqlnet-v2") | str("sun-rpc") | str("talk") | str("tftp") | str("traceroute") | str("https") | str("winframe") | str("http") | str("imap") | str("smtp") | str("ssh") | str("telnet") | str("twamp"))
            ),
            b(str("protocol"),
              (str("icmp6") | str("icmpv6") | str("igmp") | str("ipip") | str("tcp") | str("egp") | str("udp") | str("rsvp") | str("gre") | str("esp") | str("ah") | str("icmp") | str("ospf") | str("pim") | str("sctp") | arg)
            ),
            b(str("source-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("destination-port"),
              (str("ftp-data") | str("ftp") | str("ssh") | str("telnet") | str("smtp") | str("tacacs") | str("tacacs-ds") | str("domain") | str("dhcp") | str("bootps") | str("bootpc") | str("tftp") | str("finger") | str("https") | str("kerberos-sec") | str("pop3") | str("sunrpc") | str("ident") | str("nntp") | str("ntp") | str("netbios-ns") | str("netbios-dgm") | str("netbios-ssn") | str("imap") | str("snmptrap") | str("snmp") | str("xdmcp") | str("bgp") | str("ldap") | str("mobileip-agent") | str("mobilip-mn") | str("msdp") | str("http") | str("snpp") | str("biff") | str("exec") | str("login") | str("who") | str("cmd") | str("syslog") | str("printer") | str("talk") | str("ntalk") | str("rip") | str("timed") | str("klogin") | str("kshell") | str("ldp") | str("krb-prop") | str("krbupdate") | str("kpasswd") | str("socks") | str("afs") | str("pptp") | str("radius") | str("radacct") | str("zephyr-srv") | str("zephyr-clt") | str("zephyr-hm") | str("nfsd") | str("eklogin") | str("ekshell") | str("rkinit") | str("cvspserver") | arg)
            ),
            b(str("icmp-type"),
              (str("echo-request") | str("echo-reply") | str("unreachable") | str("source-quench") | str("redirect") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("timestamp") | str("timestamp-reply") | str("info-request") | str("info-reply") | str("mask-request") | str("mask-reply") | arg)
            ),
            b(str("icmp-code"),
              (str("network-unreachable") | str("host-unreachable") | str("protocol-unreachable") | str("port-unreachable") | str("fragmentation-needed") | str("source-route-failed") | str("destination-network-unknown") | str("destination-host-unknown") | str("source-host-isolated") | str("destination-network-prohibited") | str("destination-host-prohibited") | str("network-unreachable-for-tos") | str("host-unreachable-for-tos") | str("communication-prohibited-by-filtering") | str("host-precedence-violation") | str("precedence-cutoff-in-effect") | str("redirect-for-network") | str("redirect-for-host") | str("redirect-for-tos-and-net") | str("redirect-for-tos-and-host") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip-header-bad") | str("required-option-missing") | arg)
            ),
            b(str("icmp6-type"),
              (str("echo-request") | str("echo-reply") | str("destination-unreachable") | str("router-advertisement") | str("router-solicit") | str("time-exceeded") | str("parameter-problem") | str("packet-too-big") | str("membership-query") | str("membership-report") | str("membership-termination") | str("redirect") | str("neighbor-solicit") | str("neighbor-advertisement") | str("router-renumbering") | str("node-information-request") | str("node-information-reply") | arg)
            ),
            b(str("icmp6-code"),
              (str("no-route-to-destination") | str("administratively-prohibited") | str("address-unreachable") | str("port-unreachable") | str("ttl-eq-zero-during-transit") | str("ttl-eq-zero-during-reassembly") | str("ip6-header-bad") | str("unrecognized-next-header") | str("unrecognized-option") | arg)
            ),
            a(str("rpc-program-number"), arg),
            a(str("uuid"), arg),
            b(str("inactivity-timeout"),
              (str("never") | arg)
            )
        )
      ).as(:oneline)
    end
    # End of vSRX 18.3R1.9
  end
end