require 'parslet'

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

      lines.inject(true) do |passed, line|
        if line =~ /^deactivate/
          if lines_without_deactivate.grep(/^#{line.sub(/^deactivate/, 'set')}/).empty?
            next false
          else
            next passed
          end
        end

        begin
          parse line
          passed
        rescue Parslet::ParseFailed
          $stderr.puts "Invalid syntax:  #{line}"
          false
        end
      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

    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_unicaset) 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(:configuration) do
          c(
              a(str("rcsid"), arg),
              a(str("version"), arg),
              b(str("groups"),
                  c(
                    b(arg,
                      configuration
                    )
                  )
              ),
              a(str("apply-groups"), arg),
              b(str("dynamic-profiles"),
                juniper_dynamic_profile_object
              ),
              b(str("system"),
                juniper_system
              ),
              b(str("logical-systems"),
                juniper_logical_system
              ),
              b(str("chassis"),
                chassis_type
              ),
              b(str("interfaces"),
                  c(
                      str("pic-set"),
                      a(str("interface-set"), arg | str("interface-set-name"),
                          c(
                              b(a(str("interface"), arg),
                                  c(
                                      a(str("unit"), arg),
                                      a(str("vlan-tags-outer"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("traceoptions"),
                          c(
                              str("no-remote-trace"),
                              b(str("file"),
                                  sca(
                                      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"), str("all") | str("kernel") | str("change-events") | str("kernel-detail") | str("config-states") | str("resource-usage") | str("gres-events") | str("select-events"),
                                  c(
                                      str("disable")
                                  )
                              ).as(:oneline)
                          )
                      ),
                      b(a(str("interface-range"), arg),
                          c(
                              a(str("member"), arg),
                              b(a(str("member-range"), arg),
                                  c(
                                      b(str("end-range"),
                                        interface_device
                                      )
                                  )
                              ).as(:oneline),
                              a(str("description"), quote | arg),
                              a(str("metadata"), arg),
                              c(
                                str("disable")
                              ),
                              str("promiscuous-mode"),
                              a(str("port-mirror-instance"), arg),
                              str("multicast-statistics"),
                              b(str("fabric-options"),
                                  c(
                                      a(str("member-interfaces"), arg)
                                  )
                              ),
                              b(str("traceoptions"),
                                  c(
                                      a(str("flag"), str("ipc") | str("event") | str("media") | str("all") | str("q921") | str("q931")).as(:oneline),
                                      b(str("file"),
                                          sca(
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable")
                                          )
                                      )
                                  )
                              ),
                              str("passive-monitor-mode"),
                              c(
                                b(str("keepalives"),
                                  keepalives_type
                                ).as(:oneline),
                                str("no-keepalives")
                              ),
                              str("traps"),
                              str("no-traps"),
                              a(str("accounting-profile"), arg),
                              c(
                                str("per-unit-scheduler"),
                                str("no-per-unit-scheduler"),
                                str("shared-scheduler"),
                                b(str("hierarchical-scheduler"),
                                    c(
                                        a(str("maximum-hierarchy-levels"), arg)
                                    )
                                ).as(:oneline)
                              ),
                              a(str("schedulers"), arg),
                              str("interface-transmit-statistics"),
                              str("dce"),
                              c(
                                str("vlan-tagging"),
                                str("stacked-vlan-tagging"),
                                str("flexible-vlan-tagging"),
                                str("vlan-vci-tagging")
                              ),
                              a(str("native-vlan-id"), arg),
                              a(str("speed"), 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("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)
                                  )
                              ),
                              str("ima-group-options"),
                              str("ima-link-options"),
                              b(str("multi-chassis-protection"),
                                multi_chassis_protection_group
                              ),
                              b(str("clocking"),
                                  c(
                                      c(
                                        str("internal"),
                                        b(str("external"),
                                            c(
                                                b(str("interface"),
                                                  interface_device
                                                )
                                            )
                                        )
                                      )
                                  )
                              ).as(:oneline),
                              a(str("link-mode"), arg),
                              a(str("media-type"), arg),
                              a(str("encapsulation"), arg),
                              b(str("framing"),
                                  c(
                                      c(
                                        str("lan-phy"),
                                        str("wan-phy"),
                                        str("sonet"),
                                        str("sdh")
                                      )
                                  )
                              ),
                              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),
                                      a(str("lmi-type"), arg)
                                  )
                              ),
                              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),
                                      a(str("action-red-differential-delay"), arg),
                                      a(str("fragment-threshold"), arg),
                                      a(str("drop-timeout"), arg),
                                      b(str("link-layer-overhead"),
                                        unsigned_float
                                      ),
                                      a(str("lmi-type"), arg),
                                      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_unicaset
                              ),
                              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(
                                      str("per-unit-mac-disable")
                                  )
                              ),
                              b(str("aggregated-sonet-options"),
                                  c(
                                      a(str("minimum-links"), arg),
                                      a(str("link-speed"), arg),
                                      a(str("minimum-bandwidth"), arg)
                                  )
                              ),
                              b(str("atm-options"),
                                  c(
                                      a(str("pic-type"), arg),
                                      a(str("cell-bundle-size"), 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"),
                                                  c(
                                                      c(
                                                        a(str("oam-period"), arg),
                                                        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),
                                          c(
                                              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(
                                              a(str("vc-cos-mode"), arg),
                                              b(a(str("forwarding-class"), arg),
                                                  c(
                                                      a(str("priority"), arg),
                                                      b(str("transmit-weight"),
                                                          c(
                                                              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"),
                                      b(str("flow-control-options"),
                                          c(
                                              str("dump-on-flow-control"),
                                              str("reset-on-flow-control"),
                                              str("down-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
                              ),
                              str("redundancy-options"),
                              str("load-balancing-options"),
                              str("lsq-failure-options"),
                              b(str("services-options"),
                                  c(
                                      b(str("syslog"),
                                        service_set_syslog_object
                                      ),
                                      a(str("open-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),
                                      str("trio-flow-offload"),
                                      str("cgn-pic"),
                                      b(str("session-limit"),
                                          c(
                                              a(str("maximum"), arg),
                                              a(str("rate"), arg)
                                          )
                                      ),
                                      b(str("ignore-errors"),
                                          c(
                                              str("tcp"),
                                              str("alg")
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(str("t3-options"),
                                  c(
                                      a(str("loopback"), arg),
                                      str("long-buildout"),
                                      str("no-long-buildout"),
                                      str("loop-timing"),
                                      str("no-loop-timing"),
                                      str("unframed"),
                                      str("no-unframed"),
                                      b(str("compatibility-mode"),
                                          c(
                                              c(
                                                b(str("larscom"),
                                                    c(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("verilink"),
                                                    c(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("adtran"),
                                                    c(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("kentrox"),
                                                    c(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("digital-link"),
                                                    c(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline)
                                              )
                                          )
                                      ).as(:oneline),
                                      str("payload-scrambler"),
                                      str("no-payload-scrambler"),
                                      str("cbit-parity"),
                                      str("no-cbit-parity"),
                                      a(str("fcs"), arg),
                                      a(str("idle-cycle-flag"), arg),
                                      a(str("start-end-flag"), arg),
                                      str("feac-loop-respond"),
                                      str("no-feac-loop-respond"),
                                      a(str("bert-algorithm"), arg),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg),
                                      a(str("buildout"), arg),
                                      a(str("atm-encapsulation"), arg)
                                  )
                              ),
                              b(str("e3-options"),
                                  c(
                                      a(str("loopback"), arg),
                                      str("unframed"),
                                      str("no-unframed"),
                                      b(str("compatibility-mode"),
                                          c(
                                              c(
                                                str("larscom"),
                                                b(str("digital-link"),
                                                    c(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline),
                                                b(str("kentrox"),
                                                    c(
                                                        a(str("subrate"), arg)
                                                    )
                                                ).as(:oneline)
                                              )
                                          )
                                      ).as(:oneline),
                                      str("payload-scrambler"),
                                      str("no-payload-scrambler"),
                                      a(str("fcs"), arg),
                                      a(str("idle-cycle-flag"), arg),
                                      str("invert-data"),
                                      a(str("start-end-flag"), arg),
                                      a(str("bert-algorithm"), arg),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg),
                                      a(str("buildout"), arg),
                                      a(str("atm-encapsulation"), arg),
                                      a(str("framing"), arg)
                                  )
                              ),
                              b(str("e1-options"),
                                  c(
                                      a(str("timeslots"), arg),
                                      a(str("loopback"), arg),
                                      a(str("framing"), arg),
                                      a(str("fcs"), arg),
                                      str("invert-data"),
                                      a(str("idle-cycle-flag"), arg),
                                      a(str("start-end-flag"), arg),
                                      a(str("bert-algorithm"), arg),
                                      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),
                                      a(str("loopback"), arg),
                                      a(str("buildout"), arg),
                                      a(str("byte-encoding"), arg),
                                      a(str("line-encoding"), arg),
                                      str("invert-data"),
                                      a(str("framing"), arg),
                                      a(str("fcs"), arg),
                                      a(str("idle-cycle-flag"), arg),
                                      a(str("start-end-flag"), arg),
                                      a(str("bert-algorithm"), arg),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg),
                                      str("remote-loopback-respond"),
                                      a(str("crc-major-alarm-threshold"), arg),
                                      a(str("crc-minor-alarm-threshold"), arg),
                                      a(str("alarm-compliance"), arg)
                                  )
                              ),
                              b(str("ds0-options"),
                                  c(
                                      a(str("loopback"), arg),
                                      a(str("byte-encoding"), arg),
                                      str("invert-data"),
                                      a(str("fcs"), arg),
                                      a(str("idle-cycle-flag"), arg),
                                      a(str("start-end-flag"), arg),
                                      a(str("bert-algorithm"), arg),
                                      a(str("bert-error-rate"), arg),
                                      a(str("bert-period"), arg)
                                  )
                              ),
                              b(str("serial-options"),
                                  c(
                                      a(str("line-protocol"), arg),
                                      c(
                                        b(str("dte-options"),
                                            c(
                                                str("ignore-all"),
                                                b(str("dtr"),
                                                    c(
                                                        c(
                                                          str("assert"),
                                                          str("de-assert"),
                                                          str("normal"),
                                                          b(str("auto-synchronize"),
                                                              c(
                                                                  a(str("duration"), arg),
                                                                  a(str("interval"), arg)
                                                              )
                                                          )
                                                        )
                                                    )
                                                ).as(:oneline),
                                                a(str("control-signal"), arg),
                                                a(str("rts"), arg),
                                                a(str("dcd"), arg),
                                                a(str("dsr"), arg),
                                                a(str("cts"), arg),
                                                a(str("indication"), arg),
                                                a(str("tm"), arg)
                                            )
                                        ),
                                        b(str("dce-options"),
                                            c(
                                                str("ignore-all"),
                                                a(str("dtr"), arg),
                                                a(str("rts"), arg),
                                                a(str("dcd"), arg),
                                                a(str("dsr"), arg),
                                                a(str("cts"), arg),
                                                a(str("tm"), arg),
                                                str("dce-loopback-override")
                                            )
                                        )
                                      ),
                                      a(str("dtr-circuit"), arg),
                                      a(str("dtr-polarity"), arg),
                                      a(str("rts-polarity"), arg),
                                      a(str("control-polarity"), arg),
                                      a(str("dcd-polarity"), arg),
                                      a(str("dsr-polarity"), arg),
                                      a(str("cts-polarity"), arg),
                                      a(str("indication-polarity"), arg),
                                      a(str("tm-polarity"), arg),
                                      a(str("clocking-mode"), arg),
                                      a(str("transmit-clock"), arg),
                                      a(str("clock-rate"), arg),
                                      a(str("loopback"), arg),
                                      a(str("encoding"), arg),
                                      a(str("idle-cycle-flag"), arg)
                                  )
                              ),
                              str("gratuitous-arp-reply"),
                              str("no-gratuitous-arp-reply"),
                              str("no-gratuitous-arp-request"),
                              str("no-no-gratuitous-arp-request"),
                              str("fibrechannel-options"),
                              b(str("ether-options") | str("gigether-options"),
                                  c(
                                      str("loopback"),
                                      str("no-loopback"),
                                      str("flow-control"),
                                      str("no-flow-control"),
                                      str("source-filtering"),
                                      str("no-source-filtering"),
                                      c(
                                        str("no-auto-negotiation"),
                                        b(str("auto-negotiation"),
                                            c(
                                                a(str("remote-fault"), arg)
                                            )
                                        ).as(:oneline)
                                      ),
                                      a(str("mac-mode"), arg),
                                      str("asynchronous-notification"),
                                      a(str("source-address-filter"), arg).as(:oneline),
                                      b(str("redundant-parent"),
                                          c(
                                              b(str("parent"),
                                                interface_device
                                              )
                                          )
                                      ),
                                      b(str("802.3ad"),
                                        ca(
                                          b(str("lacp"),
                                            c(
                                              str("force-up"),
                                                      a(str("port-priority"), arg)
                                                  )
                                              ),
                                              b(str("bundle"),
                                                interface_device
                                              ),
                                              a(str("link-index"), arg),
                                              c(
                                                str("primary"),
                                                str("backup")
                                              )
                                          )
                                      ),
                                      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
                                                      )
                                                  )
                                              ),
                                              str("mac-learn-enable"),
                                              str("no-mac-learn-enable")
                                          )
                                      ),
                                      b(str("mpls"),
                                        mpls_ifd_options
                                      ),
                                      str("ignore-l3-incompletes"),
                                      str("no-auto-mdix")
                                  )
                              ),
                              b(str("optics-options"),
                                  c(
                                      a(str("wavelength"), arg),
                                      a(str("alarm"), str("low-light-alarm"),
                                          c(
                                              c(
                                                str("syslog"),
                                                str("link-down")
                                              )
                                          )
                                      ),
                                      a(str("warning"), str("low-light-warning"),
                                          c(
                                              c(
                                                str("syslog"),
                                                str("link-down")
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("otn-options"),
                                otn_options_type
                              ),
                              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(
                                              b(str("parent"),
                                                interface_device
                                              )
                                          )
                                      ),
                                      b(str("802.3ad"),
                                        ca(
                                          b(str("lacp"),
                                            c(
                                              str("force-up"),
                                                      a(str("port-priority"), arg)
                                                  )
                                              ),
                                              b(str("bundle"),
                                                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),
                                      a(str("link-speed"), arg),
                                      a(str("minimum-links"), arg),
                                      b(str("lacp"),
                                          c(
                                              c(
                                                str("active"),
                                                str("passive")
                                              ),
                                              a(str("periodic"), arg)
                                          )
                                      )
                                  )
                              ),
                              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("link-protection"),
                                      str("no-link-protection"),
                                      str("source-address-filter").as(:oneline),
                                      a(str("minimum-links"), arg),
                                      str("logical-interface-fpc-redundancy"),
                                      b(str("rebalance-periodic"),
                                          c(
                                              b(str("start-time"),
                                                time
                                              ),
                                              a(str("interval"), arg)
                                          )
                                      ),
                                      a(str("link-speed"), arg),
                                      b(str("lacp"),
                                          c(
                                              c(
                                                str("active"),
                                                str("passive")
                                              ),
                                              a(str("periodic"), arg),
                                              b(str("link-protection"),
                                                  c(
                                                      str("disable"),
                                                      c(
                                                        str("revertive"),
                                                        str("non-revertive")
                                                      )
                                                  )
                                              ),
                                              a(str("system-priority"), arg),
                                              b(str("system-id"),
                                                mac_addr
                                              ),
                                              a(str("admin-key"), arg)
                                          )
                                      ),
                                      b(str("ethernet-switch-profile"),
                                          c(
                                              a(str("tag-protocol-id"), arg)
                                          )
                                      ),
                                      str("mc-ae")
                                  )
                              ),
                              b(str("es-options"),
                                  c(
                                      b(str("backup-interface"),
                                        interface_device
                                      )
                                  )
                              ),
                              b(str("dsl-options"),
                                  c(
                                      a(str("operating-mode"), arg)
                                  )
                              ),
                              b(str("vdsl-options"),
                                  c(
                                      a(str("vdsl-profile"), arg)
                                  )
                              ),
                              b(str("shdsl-options"),
                                  c(
                                      a(str("annex"), arg),
                                      a(str("line-rate"), arg),
                                      a(str("loopback"), arg),
                                      b(str("snr-margin"),
                                          c(
                                              a(str("current"), arg),
                                              a(str("snext"), 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"),
                                              a(str("link-mode"), arg),
                                              a(str("speed"), arg),
                                              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(
                                                        a(str("member-interface-speed"), arg)
                                                    )
                                                ),
                                                b(str("atm"),
                                                    c(
                                                        a(str("member-interface-speed"), arg)
                                                    )
                                                )
                                              )
                                          )
                                      ),
                                      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("allow-configuration-override")
                                  )
                              ),
                              str("layer2-policer"),
                              a(str("unit"), arg | arg | str("interface-unit-number"),
                                  c(
                                      b(str("peer-psd"),
                                          c(
                                              a(str("psd-name"), arg)
                                          )
                                      ).as(:oneline),
                                      b(str("peer-interface"),
                                          c(
                                              b(str("interface-name"),
                                                interface_unit
                                              )
                                          )
                                      ),
                                      b(str("interface-shared-with"),
                                          c(
                                              a(str("psd-name"), arg)
                                          )
                                      ),
                                      c(
                                        str("disable")
                                      ),
                                      str("passive-monitor-mode"),
                                      str("per-session-scheduler"),
                                      str("clear-dont-fragment-bit"),
                                      str("reassemble-packets"),
                                      str("rpm"),
                                      a(str("description"), quote | arg),
                                      a(str("metadata"), arg),
                                      str("dial-options"),
                                      b(str("demux-source"),
                                            (str("inet") | str("inet6"))
                                      ),
                                      b(str("demux-destination"),
                                            (str("inet") | str("inet6"))
                                      ),
                                      a(str("encapsulation"), arg),
                                      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"),
                                      b(str("arp-resp"),
                                          c(
                                              c(
                                                str("unrestricted"),
                                                str("restricted")
                                              )
                                          )
                                      ).as(:oneline),
                                      b(str("proxy-arp"),
                                          c(
                                              c(
                                                str("unrestricted"),
                                                str("restricted")
                                              )
                                          )
                                      ).as(:oneline),
                                      c(
                                        a(str("vlan-id"), arg),
                                        a(str("vlan-id-range"), arg),
                                        a(str("vlan-id-list"), arg),
                                        b(str("vlan-tags"),
                                            c(
                                                a(str("outer"), arg),
                                                c(
                                                  a(str("inner"), arg),
                                                  a(str("inner-range"), arg),
                                                  a(str("inner-list"), arg)
                                                )
                                            )
                                        ).as(:oneline)
                                      ),
                                      a(str("native-inner-vlan-id"), arg),
                                      str("inner-vlan-id-range").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"),
                                          c(
                                              c(
                                                str("cell"),
                                                str("aal5")
                                              )
                                          )
                                      ).as(:oneline),
                                      b(str("vci-range"),
                                          c(
                                              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"),
                                          c(
                                              c(
                                                a(str("oam-period"), arg),
                                                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("demux-options"),
                                        demux_options_type
                                      ),
                                      str("targetted-distribution"),
                                      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),
                                      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),
                                                      a(str("queues"), arg),
                                                      b(str("port"),
                                                          c(
                                                              a(str("minimum"), arg),
                                                              a(str("maximum"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("maximum-contexts"),
                                                          c(
                                                              a(str("number"), 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("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
                                      ),
                                      str("atm-policer"),
                                      str("layer2-policer"),
                                      str("filter"),
                                      b(str("multi-chassis-protection"),
                                        multi_chassis_protection_group
                                      ),
                                      b(str("family"),
                                          c(
                                              b(str("inet"),
                                                  c(
                                                      b(str("targeted-broadcast"),
                                                          c(
                                                              c(
                                                                str("forward-and-send-to-re"),
                                                                str("forward-only")
                                                              )
                                                          )
                                                      ),
                                                      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")
                                                          )
                                                      ),
                                                      a(str("mac-validate"), arg),
                                                      b(str("rpf-check"),
                                                          c(
                                                              a(str("fail-filter"), arg),
                                                              b(str("mode"),
                                                                  c(
                                                                      str("loose")
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ),
                                                      a(str("mtu"), arg),
                                                      str("no-redirects"),
                                                      str("no-neighbor-learn"),
                                                      str("unconditional-src-learn"),
                                                      str("multicast-only"),
                                                      str("primary"),
                                                      a(str("ipsec-sa"), arg),
                                                      str("demux-source"),
                                                      str("demux-destination"),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                b(str("input"),
                                                                    ca(
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              c(
                                                                b(str("output"),
                                                                    ca(
                                                                        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),
                                                                      a(str("output-precedence"), arg)
                                                                  )
                                                              ),
                                                              a(str("group"), arg),
                                                              a(str("dialer"), arg)
                                                          )
                                                      ),
                                                      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(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"),
                                                                          c(
                                                                              c(
                                                                                a(str("oam_period"), arg),
                                                                                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),
                                                                  c(
                                                                      b(str("l2-interface"),
                                                                        interface_name
                                                                      ),
                                                                      c(
                                                                        b(str("mac"),
                                                                          mac_unicaset
                                                                        ),
                                                                        b(str("multicast-mac"),
                                                                          mac_multicast
                                                                        )
                                                                      ),
                                                                      str("publish")
                                                                  )
                                                              ).as(:oneline),
                                                              b(str("web-authentication"),
                                                                  c(
                                                                      str("http"),
                                                                      str("https"),
                                                                      str("redirect-to-https")
                                                                  )
                                                              ),
                                                              b(str("vrrp-group"),
                                                                vrrp_group
                                                              )
                                                          )
                                                      ),
                                                      b(str("unnumbered-address"),
                                                          c(
                                                              b(str("source"),
                                                                interface_unit
                                                              ),
                                                              a(str("preferred-source-address"), arg),
                                                              b(str("destination"),
                                                                ipv4addr
                                                              ),
                                                              a(str("destination-profile"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      str("location-pool-address"),
                                                      str("negotiate-address"),
                                                      b(str("dhcp"),
                                                          c(
                                                              b(str("client-identifier"),
                                                                  c(
                                                                      c(
                                                                        a(str("ascii"), arg),
                                                                        a(str("hexadecimal"), arg)
                                                                      )
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("lease-time"), arg),
                                                              a(str("retransmission-attempt"), arg),
                                                              a(str("retransmission-interval"), arg),
                                                              b(str("server-address"),
                                                                ipv4addr
                                                              ),
                                                              str("update-server"),
                                                              a(str("vendor-id"), arg)
                                                          )
                                                      ),
                                                      b(str("dhcp-client"),
                                                        dhcp_client_type
                                                      )
                                                  )
                                              ),
                                              b(str("iso"),
                                                  c(
                                                      a(str("address"), arg),
                                                      a(str("mtu"), arg)
                                                  )
                                              ),
                                              b(str("inet6"),
                                                  c(
                                                      b(str("rpf-check"),
                                                          c(
                                                              a(str("fail-filter"), arg),
                                                              b(str("mode"),
                                                                  c(
                                                                      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("nd6-stale-time"), arg),
                                                      str("no-neighbor-learn"),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                b(str("input"),
                                                                    ca(
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              c(
                                                                b(str("output"),
                                                                    ca(
                                                                        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),
                                                                      a(str("output-precedence"), arg)
                                                                  )
                                                              ),
                                                              a(str("group"), arg),
                                                              a(str("dialer"), arg)
                                                          )
                                                      ),
                                                      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(a(str("address"), arg),
                                                          c(
                                                              b(str("destination"),
                                                                ipv6addr
                                                              ),
                                                              str("eui-64"),
                                                              str("primary"),
                                                              str("preferred"),
                                                              str("master-only"),
                                                              b(a(str("ndp"), arg),
                                                                  c(
                                                                      b(str("l2-interface"),
                                                                        interface_name
                                                                      ),
                                                                      c(
                                                                        b(str("mac"),
                                                                          mac_unicaset
                                                                        ),
                                                                        b(str("multicast-mac"),
                                                                          mac_multicast
                                                                        )
                                                                      ),
                                                                      str("publish")
                                                                  )
                                                              ).as(:oneline),
                                                              b(str("vrrp-inet6-group"),
                                                                vrrp_group
                                                              ),
                                                              b(str("web-authentication"),
                                                                  c(
                                                                      str("http"),
                                                                      str("https"),
                                                                      str("redirect-to-https")
                                                                  )
                                                              )
                                                          )
                                                      ),
                                                      str("demux-source"),
                                                      str("demux-destination"),
                                                      b(str("unnumbered-address"),
                                                          c(
                                                              b(str("source"),
                                                                interface_unit
                                                              ),
                                                              a(str("preferred-source-address"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      str("dad-disable"),
                                                      str("no-dad-disable"),
                                                      b(str("dhcpv6-client"),
                                                          c(
                                                              a(str("client-type"), arg),
                                                              a(str("client-ia-type"), str("ia-na") | str("ia-pd")),
                                                              str("rapid-commit"),
                                                              b(str("update-router-advertisement"),
                                                                  c(
                                                                      a(str("interface"), arg)
                                                                  )
                                                              ),
                                                              b(str("client-identifier"),
                                                                  c(
                                                                      a(str("duid-type"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("req-option"), 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("update-server"),
                                                              a(str("retransmission-attempt"), 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)
                                                              ),
                                                              c(
                                                                a(str("output"), arg),
                                                                a(str("output-list"), arg)
                                                              ),
                                                              a(str("group"), arg),
                                                              a(str("dialer"), arg)
                                                          )
                                                      ),
                                                      a(str("input-hierarchical-policer"), arg),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("mlppp"),
                                                  c(
                                                      b(str("bundle"),
                                                        interface_unit
                                                      )
                                                  )
                                              ),
                                              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(
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                a(str("input"), arg),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              c(
                                                                a(str("output"), arg),
                                                                a(str("output-list"), arg)
                                                              ),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      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
                                                              )
                                                          )
                                                      ),
                                                      str("protocols")
                                                  )
                                              ),
                                              b(str("vpls"),
                                                  c(
                                                      str("core-facing"),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                b(str("input"),
                                                                    ca(
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              c(
                                                                b(str("output"),
                                                                    ca(
                                                                        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),
                                                                      a(str("output-precedence"), arg)
                                                                  )
                                                              ),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("bridge"),
                                                  c(
                                                      str("core-facing"),
                                                      b(str("filter"),
                                                          c(
                                                              c(
                                                                b(str("input"),
                                                                    ca(
                                                                        a(str("precedence"), arg)
                                                                    )
                                                                ).as(:oneline),
                                                                a(str("input-list"), arg)
                                                              ),
                                                              c(
                                                                b(str("output"),
                                                                    ca(
                                                                        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),
                                                                      a(str("output-precedence"), arg)
                                                                  )
                                                              ),
                                                              a(str("group"), arg)
                                                          )
                                                      ),
                                                      b(str("policer"),
                                                          c(
                                                              a(str("input"), arg),
                                                              a(str("output"), arg)
                                                          )
                                                      ),
                                                      a(str("interface-mode"), arg),
                                                      a(str("bridge-domain-type"), arg),
                                                      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),
                                                                  c(
                                                                      a(str("to-vlan-id"), arg)
                                                                  )
                                                              ).as(:oneline)
                                                          )
                                                      ),
                                                      c(
                                                        a(str("isid-list"), arg)
                                                      ),
                                                      b(str("storm-control"),
                                                        storm_control
                                                      )
                                                  )
                                              ),
                                              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)
                                                          )
                                                      )
                                                  )
                                              )
                                          )
                                      ),
                                      a(str("service-domain"), arg),
                                      str("copy-tos-to-outer-ip-header"),
                                      b(str("dialer-options"),
                                          c(
                                              a(str("pool"), arg),
                                              a(str("dial-string"), arg),
                                              b(str("incoming-map"),
                                                  c(
                                                      c(
                                                        a(str("caller"), arg).as(:oneline),
                                                        str("accept-all")
                                                      )
                                                  )
                                              ),
                                              str("callback"),
                                              a(str("callback-wait-period"), arg),
                                              a(str("redial-delay"), arg),
                                              a(str("idle-timeout"), arg),
                                              a(str("watch-list"), arg),
                                              a(str("load-threshold"), arg),
                                              a(str("load-interval"), arg),
                                              a(str("activation-delay"), arg),
                                              a(str("deactivation-delay"), arg),
                                              a(str("initial-route-check"), arg)
                                          )
                                      ),
                                      b(str("backup-options"),
                                          c(
                                              b(str("interface"),
                                                interface_name
                                              )
                                          )
                                      ),
                                      str("dynamic-call-admission-control")
                                  )
                              ),
                              b(str("no-partition"),
                                  c(
                                      a(str("interface-type"), arg)
                                  )
                              ).as(:oneline),
                              b(a(str("partition"), arg),
                                  c(
                                      a(str("oc-slice"), arg),
                                      a(str("timeslots"), arg),
                                      a(str("interface-type"), arg)
                                  )
                              ).as(:oneline),
                              b(str("modem-options"),
                                  c(
                                      a(str("init-command-string"), arg),
                                      a(str("dialin"), arg)
                                  )
                              ),
                              b(str("isdn-options"),
                                  c(
                                      a(str("switch-type"), arg),
                                      a(str("media-type"), arg),
                                      a(str("spid1"), arg),
                                      a(str("spid2"), arg),
                                      a(str("calling-number"), arg),
                                      b(a(str("incoming-called-number"), arg),
                                          c(
                                              str("reject")
                                          )
                                      ).as(:oneline),
                                      a(str("tei-option"), arg),
                                      a(str("static-tei-val"), arg),
                                      a(str("t310"), arg),
                                      a(str("bchannel-allocation"), arg)
                                  )
                              ),
                              b(str("dialer-options"),
                                  c(
                                      b(a(str("pool"), arg),
                                          c(
                                              a(str("priority"), arg)
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(str("redundant-pseudo-interface-options"),
                                  c(
                                      a(str("redundancy-group"), arg)
                                  )
                              ),
                              str("cellular-options")
                          )
                      ),
                      interfaces_type
                  )
              ),
              b(str("forwarding-options"),
                juniper_forwarding_options
              ),
              b(str("event-options"),
                  c(
                      b(a(str("generate-event"), arg),
                          c(
                              c(
                                b(str("time-of-day"),
                                  time
                                ),
                                a(str("time-interval"), arg)
                              )
                          )
                      ).as(:oneline),
                      b(a(str("policy"), arg),
                          c(
                              a(str("events"), arg),
                              b(a(str("within"), arg),
                                  c(
                                      b(str("trigger"),
                                          c(
                                              c(
                                                str("until"),
                                                str("on"),
                                                str("after")
                                              ),
                                              a(str("count"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("events"), arg),
                                      b(str("not"),
                                          c(
                                              a(str("events"), arg)
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(str("attributes-match"),
                                  s(
                                    a(str("from-event-attribute"), arg),
                                    b(str("condition"),
                                          (str("equals") | str("starts-with") | str("matches"))
                                    ),
                                    a(str("to-event-attribute-value"), arg)
                                  )
                              ).as(:oneline),
                              b(str("then"),
                                  c(
                                      str("ignore"),
                                      b(str("priority-override"),
                                          c(
                                              a(str("facility"), arg),
                                              a(str("severity"), arg)
                                          )
                                      ),
                                      b(str("upload"),
                                          s(
                                            b(str("filename"),
                                                  arg
                                            ),
                                            a(str("destination"), arg),
                                            c(
                                              a(str("user-name"), arg),
                                              a(str("transfer-delay"), arg),
                                              b(str("retry-count"),
                                                  c(
                                                      a(str("retry"), arg),
                                                      a(str("retry-interval"), arg)
                                                  )
                                              ).as(:oneline)
                                            )
                                          )
                                      ),
                                      b(str("change-configuration"),
                                          c(
                                              b(str("retry"),
                                                  c(
                                                      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"),
                                                          c(
                                                              a(str("retry"), arg),
                                                              a(str("retry-interval"), arg)
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              ),
                                              a(str("output-format"), arg)
                                          )
                                      ),
                                      b(a(str("event-script"), arg),
                                          c(
                                              b(a(str("arguments"), arg),
                                                  c(
                                                      a(str("value"), 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"),
                                                          c(
                                                              a(str("retry"), arg),
                                                              a(str("retry-interval"), arg)
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              ),
                                              a(str("output-format"), arg)
                                          )
                                      ),
                                      str("raise-trap")
                                  )
                              )
                          )
                      ),
                      b(str("event-script"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable")
                                          )
                                      ).as(:oneline),
                                      a(str("flag"), 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),
                                      str("refresh"),
                                      a(str("refresh-from"), arg),
                                      b(str("checksum"),
                                          c(
                                              a(str("md5"), arg),
                                              a(str("sha1"), arg),
                                              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),
                                  c(
                                      b(str("password"),
                                        unreadable
                                      )
                                  )
                              ).as(:oneline)
                          )
                      ),
                      b(str("traceoptions"),
                          c(
                              str("no-remote-trace"),
                              b(str("file"),
                                  sca(
                                      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"), str("server") | str("configuration") | str("events") | str("timer-events") | str("database") | str("policy") | str("registration") | str("syslogd") | str("all")).as(:oneline)
                          )
                      )
                  )
              ),
              b(str("snmp"),
                  c(
                      a(str("system-name"), arg),
                      a(str("description"), quote | arg),
                      a(str("location"), arg),
                      a(str("contact"), arg),
                      b(str("interface"),
                        interface_name
                      ),
                      b(str("filter-interfaces"),
                          c(
                              a(str("interfaces"), arg),
                              str("all-internal-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"), 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(
                                              a(str("message-processing-model"), arg),
                                              a(str("security-model"), arg),
                                              a(str("security-level"), arg),
                                              a(str("security-name"), arg)
                                          )
                                      ),
                                      b(str("notify-filter"),
                                          c(
                                              a(str("filter"), arg)
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              b(a(str("notify"), arg),
                                  c(
                                      a(str("type"), arg),
                                      a(str("tag"), arg)
                                  )
                              ),
                              b(a(str("notify-filter"), arg),
                                  c(
                                      b(a(str("oid"), arg),
                                          c(
                                              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(str("engine-id"),
                          c(
                              c(
                                str("use-mac-address"),
                                str("use-default-ip-address"),
                                a(str("local"), arg)
                              )
                          )
                      ),
                      b(a(str("view"), arg),
                          c(
                              b(a(str("oid"), arg),
                                  c(
                                      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),
                              a(str("authorization"), arg),
                              c(
                                a(str("client-list-name"), arg),
                                b(a(str("clients"), arg),
                                    c(
                                        str("restrict")
                                    )
                                ).as(:oneline)
                              ),
                              b(a(str("routing-instance"), arg),
                                  c(
                                      c(
                                        a(str("client-list-name"), arg),
                                        b(a(str("clients"), arg),
                                            c(
                                                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),
                                                    c(
                                                        str("restrict")
                                                    )
                                                ).as(:oneline)
                                              )
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("trap-options"),
                          c(
                              b(str("source-address"),
                                  c(
                                      c(
                                        str("lo0"),
                                        b(str("address"),
                                          ipv4addr
                                        )
                                      )
                                  )
                              ),
                              str("enterprise-oid"),
                              b(a(str("routing-instance"), arg),
                                  c(
                                      b(str("source-address"),
                                          c(
                                              c(
                                                str("lo0"),
                                                b(str("address"),
                                                  ipv4addr
                                                )
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(a(str("logical-system"), arg),
                                  c(
                                      b(a(str("routing-instance"), arg),
                                          c(
                                              b(str("source-address"),
                                                  c(
                                                      c(
                                                        str("lo0"),
                                                        b(str("address"),
                                                          ipv4addr
                                                        )
                                                      )
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              a(str("agent-address"), arg)
                          )
                      ),
                      b(a(str("trap-group"), arg),
                          c(
                              a(str("version"), arg),
                              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"),
                                      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),
                                  c(
                                      str("restrict")
                                  )
                              ).as(:oneline)
                          )
                      ),
                      str("logical-system-trap-filter"),
                      b(str("traceoptions"),
                          c(
                              str("no-remote-trace"),
                              b(str("file"),
                                  c(
                                      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"), 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(
                              str("history"),
                              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),
                                      a(str("sample-type"), arg),
                                      a(str("request-type"), arg),
                                      a(str("startup-alarm"), arg),
                                      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),
                                      a(str("type"), arg),
                                      a(str("community"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("health-monitor"),
                          c(
                              str("routing-engine"),
                              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("accounting-options"),
                juniper_accounting_options
              ),
              b(str("routing-options"),
                juniper_routing_options
              ),
              b(str("multicast-snooping-options"),
                juniper_multicast_snooping_options
              ),
              b(str("protocols"),
                juniper_protocols
              ),
              b(str("policy-options"),
                juniper_policy_options
              ),
              b(str("class-of-service"),
                juniper_class_of_service_options
              ),
              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(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"),
                              a(str("mode"), arg),
                              a(str("event-rate"), arg),
                              a(str("format"), arg),
                              a(str("rate-cap"), arg),
                              c(
                                b(str("source-address"),
                                  ipaddr
                                ),
                                b(str("source-interface"),
                                  interface_name
                                )
                              ),
                              b(str("transport"),
                                  c(
                                      a(str("tcp-connections"), arg),
                                      a(str("protocol"), arg),
                                      a(str("tls-profile"), arg)
                                  )
                              ),
                              b(a(str("stream"), arg),
                                  c(
                                      a(str("severity"), arg),
                                      a(str("format"), arg),
                                      a(str("category"), arg),
                                      b(str("host"),
                                        host_object
                                      )
                                  )
                              ),
                              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"),
                                          sca(
                                              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"), 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),
                                      a(str("encoding"), arg)
                                  )
                              )
                          )
                      ),
                      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-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("idp"),
                          c(
                              b(str("idp-policy"),
                                idp_policy_type
                              ),
                              a(str("active-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
                                      ),
                                      b(str("install"),
                                          c(
                                              str("ignore-version-check")
                                          )
                                      ),
                                      b(str("automatic"),
                                          c(
                                              b(str("start-time"),
                                                time
                                              ),
                                              a(str("interval"), arg),
                                              c(
                                                str("enable")
                                              )
                                          )
                                      )
                                  )
                              ),
                              b(str("sensor-configuration"),
                                  c(
                                      b(str("log"),
                                          c(
                                              a(str("cache-size"), arg),
                                              b(str("suppression"),
                                                  c(
                                                      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(
                                                      b(str("ipaddr"),
                                                        ipv4addr
                                                      ),
                                                      a(str("port"), arg)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("application-identification"),
                                          c(
                                              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-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)
                                          )
                                      ),
                                      b(str("re-assembler"),
                                          c(
                                              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-flow-mem"), arg),
                                              a(str("max-packet-mem-ratio"), arg),
                                              a(str("action-on-reassembly-failure"), arg),
                                              str("tcp-error-logging"),
                                              str("no-tcp-error-logging"),
                                              a(str("max-synacks-queued"), arg)
                                          )
                                      ),
                                      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("gtp"),
                                                  c(
                                                      str("decapsulation"),
                                                      str("no-decapsulation")
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("detector"),
                                          c(
                                              b(str("protocol-name"),
                                                proto_object
                                              )
                                          )
                                      ),
                                      str("ssl-inspection"),
                                      str("disable-low-memory-handling"),
                                      b(str("high-availability"),
                                          c(
                                              str("no-policy-cold-synchronization")
                                          )
                                      ),
                                      b(str("security-configuration"),
                                          c(
                                              a(str("protection-mode"), arg)
                                          )
                                      )
                                  )
                              ),
                              str("processes")
                          )
                      ),
                      b(str("ike"),
                        security_ike
                      ),
                      b(str("ipsec"),
                        security_ipsec_vpn
                      ),
                      b(str("group-vpn"),
                        security_group_vpn
                      ),
                      b(str("address-book"),
                        named_address_book_type
                      ),
                      b(str("alg"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              a(str("size"), arg),
                                              a(str("files"), arg),
                                              str("world-readable"),
                                              str("no-world-readable"),
                                              b(str("match"),
                                                regular_expression
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("level"), arg)
                                  )
                              ),
                              b(str("alg-manager"),
                                  c(
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("alg-support-lib"),
                                  c(
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("dns"),
                                  c(
                                      str("disable"),
                                      a(str("maximum-message-length"), arg),
                                      b(str("doctoring"),
                                          c(
                                              c(
                                                str("none"),
                                                str("sanity-check")
                                              )
                                          )
                                      ),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ),
                              b(str("ftp"),
                                  c(
                                      str("disable"),
                                      str("ftps-extension"),
                                      str("line-break-extension"),
                                      str("allow-mismatch-ip-address"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      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"),
                                                          c(
                                                              a(str("threshold"), arg)
                                                          )
                                                      ).as(:oneline)
                                                  )
                                              )
                                          )
                                      ),
                                      b(str("dscp-rewrite"),
                                          c(
                                              a(str("code-point"), arg)
                                          )
                                      ),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("q931") | str("h245") | str("ras") | str("h225-asn1") | str("h245-asn1") | str("ras-asn1") | str("chassis-cluster") | str("all"),
                                                  c(
                                                      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"),
                                                  c(
                                                      a(str("threshold"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("connection-flood"),
                                                  c(
                                                      a(str("threshold"), arg)
                                                  )
                                              ).as(:oneline)
                                          )
                                      ),
                                      b(str("dscp-rewrite"),
                                          c(
                                              a(str("code-point"), arg)
                                          )
                                      ),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("call") | str("decode") | str("error") | str("chassis-cluster") | str("nat") | str("packet") | str("rm") | str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ),
                              b(str("msrpc"),
                                  c(
                                      str("disable"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("sunrpc"),
                                  c(
                                      str("disable"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("rsh"),
                                  c(
                                      str("disable"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("rtsp"),
                                  c(
                                      str("disable"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      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"),
                                                  c(
                                                      a(str("threshold"), arg)
                                                  )
                                              ).as(:oneline)
                                          )
                                      ),
                                      b(str("dscp-rewrite"),
                                          c(
                                              a(str("code-point"), arg)
                                          )
                                      ),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("call") | str("cli") | str("decode") | str("error") | str("chassis-cluster") | str("init") | str("nat") | str("rm") | str("all"),
                                                  c(
                                                      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("retain-hold-resource"),
                                      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"), str("call") | str("chassis-cluster") | str("nat") | str("parser") | str("rm") | str("all"),
                                                  c(
                                                      c(
                                                        str("terse"),
                                                        str("detail"),
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ),
                              b(str("sql"),
                                  c(
                                      str("disable"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("talk"),
                                  c(
                                      str("disable"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("tftp"),
                                  c(
                                      str("disable"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              ).as(:oneline),
                              b(str("pptp"),
                                  c(
                                      str("disable"),
                                      b(str("traceoptions"),
                                          c(
                                              a(str("flag"), str("all"),
                                                  c(
                                                      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"), str("all"),
                                                  c(
                                                      c(
                                                        str("extensive")
                                                      )
                                                  )
                                              ).as(:oneline)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      str("application-firewall"),
                      str("application-tracking"),
                      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("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("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
                              )
                          )
                      ),
                      str("dynamic-vpn"),
                      b(str("softwires"),
                          c(
                              b(str("softwire-name"),
                                softwire_option_type
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              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"), str("configuration") | str("flow") | str("all")).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("forwarding-options"),
                          c(
                              b(str("family"),
                                  c(
                                      b(str("inet6"),
                                          c(
                                              a(str("mode"), arg)
                                          )
                                      ),
                                      b(str("mpls"),
                                          c(
                                              a(str("mode"), arg)
                                          )
                                      ),
                                      b(str("iso"),
                                          c(
                                              a(str("mode"), arg)
                                          )
                                      )
                                  )
                              ),
                              b(str("mirror-filter"),
                                mirror_filter_type
                              )
                          )
                      ),
                      str("advanced-services"),
                      b(str("flow"),
                          c(
                              str("enhanced-routing-mode"),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              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"), 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")
                                              )
                                          )
                                      )
                                  )
                              ),
                              a(str("pending-sess-queue-length"), arg),
                              str("allow-dns-reply"),
                              a(str("route-change-timeout"), arg),
                              a(str("syn-flood-protection-mode"), arg),
                              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("bridge"),
                                  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("time-wait-state"),
                                          c(
                                              c(
                                                str("session-ageout"),
                                                a(str("session-timeout"), arg)
                                              ),
                                              str("apply-to-half-close-state")
                                          )
                                      )
                                  )
                              ),
                              str("force-ip-reassembly"),
                              b(str("load-distribution"),
                                  c(
                                      str("session-affinity")
                                  )
                              )
                          )
                      ),
                      b(str("firewall-authentication"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      a(str("flag"), str("authentication") | str("proxy") | str("all"),
                                          c(
                                              c(
                                                str("terse"),
                                                str("detail"),
                                                str("extensive")
                                              )
                                          )
                                      ).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("screen"),
                          c(
                              b(str("ids-option"),
                                ids_option_type
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              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"), str("configuration") | str("flow") | str("all")).as(:oneline)
                                  )
                              )
                          )
                      ),
                      b(str("nat"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              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"), 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"),
                                          c(
                                              str("syslog")
                                          )
                                      ).as(:oneline)
                                  )
                              ),
                              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("forwarding-process"),
                      b(str("policies"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              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"), str("configuration") | str("routing-socket") | str("compilation") | str("ipc") | str("rules") | str("lookup") | str("all")).as(:oneline)
                                  )
                              ),
                              b(str("policy"),
                                  s(
                                    a(str("from-zone-name"), arg),
                                    a(str("to-zone-name"), arg),
                                    c(
                                      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")
                                      )
                                  )
                              ),
                              str("policy-rematch"),
                              b(str("policy-stats"),
                                  c(
                                      a(str("system-wide"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("resource-manager"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      a(str("flag"), str("client") | str("group") | str("resource") | str("gate") | str("session") | str("chassis cluster") | str("messaging") | str("service pinhole") | str("error") | str("all"),
                                          c(
                                              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"),
                                  sca(
                                      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"), str("configuration") | str("routing-socket") | str("compilation") | str("all")).as(:oneline),
                              a(str("rate-limit"), arg)
                          )
                      ),
                      str("datapath-debug"),
                      b(str("user-identification"),
                          c(
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              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"), 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("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("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("mpls"),
                                  c(
                                      b(str("dialer-filter"),
                                        mpls_dialer_filter
                                      ),
                                      b(str("filter"),
                                        mpls_filter
                                      )
                                  )
                              ),
                              b(str("vpls"),
                                  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
                                      )
                                  )
                              ),
                              str("ethernet-switching")
                          )
                      ),
                      b(str("policer"),
                        firewall_policer
                      ),
                      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("services"),
                  c(
                      b(str("mobile-ip"),
                        juniper_protocols_mobile_ipv4
                      ),
                      str("captive-portal-content-delivery"),
                      str("dynamic-flow-capture"),
                      str("flow-tap"),
                      str("radius-flow-tap"),
                      b(str("flow-monitoring"),
                          c(
                              b(str("version9"),
                                  c(
                                      b(str("template"),
                                        version9_template
                                      )
                                  )
                              ),
                              str("version-ipfix")
                          )
                      ),
                      b(str("rpm"),
                          c(
                              b(str("bgp"),
                                  c(
                                      a(str("probe-type"), arg),
                                      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),
                                      b(str("logical-system"),
                                        bgp_logical_system
                                      ),
                                      b(str("routing-instances"),
                                        bgp_routing_instances
                                      )
                                  )
                              ),
                              b(a(str("probe"), arg),
                                  c(
                                      b(a(str("test"), arg),
                                          c(
                                              a(str("probe-type"), arg),
                                              b(str("target"),
                                                  c(
                                                      c(
                                                        b(str("address"),
                                                          ipv4addr
                                                        ),
                                                        a(str("url"), arg)
                                                      )
                                                  )
                                              ).as(:oneline),
                                              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),
                                              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)
                                                  )
                                              ),
                                              a(str("traps"), arg),
                                              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),
                              str("twamp")
                          )
                      ),
                      str("flow-collector"),
                      str("application-identification"),
                      str("ssl"),
                      str("stateful-firewall"),
                      str("softwire"),
                      str("aacl"),
                      str("ptsp"),
                      str("hcm"),
                      str("cos"),
                      str("pgcp"),
                      str("border-signaling-gateway"),
                      str("ids"),
                      a(str("nat"), service_nat_object),
                      str("l2tp"),
                      str("adaptive-services-pics"),
                      a(str("service-set"), service_set_object),
                      b(str("service-interface-pools"),
                          c(
                              b(str("pool"),
                                service_interface_pool_object
                              )
                          )
                      ),
                      b(str("service-device-pools"),
                          c(
                              b(str("pool"),
                                service_device_pool_object
                              )
                          )
                      ),
                      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)
                                  )
                              ),
                              a(str("certificate-verification"), arg),
                              a(str("timeout"), arg),
                              a(str("interval"), arg),
                              a(str("timeout-action"), arg),
                              str("test-only-mode"),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              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"), str("all") | str("ipc") | str("config") | str("connect")).as(:oneline)
                                  )
                              ),
                              b(a(str("captive-portal"), arg),
                                  c(
                                      a(str("redirect-traffic"), arg),
                                      a(str("redirect-url"), arg)
                                  )
                              )
                          )
                      ),
                      b(str("user-identification"),
                          c(
                              b(str("active-directory-access"),
                                  c(
                                      b(str("traceoptions"),
                                          c(
                                              str("no-remote-trace"),
                                              b(str("file"),
                                                  sca(
                                                      a(str("size"), arg),
                                                      a(str("files"), arg),
                                                      str("world-readable"),
                                                      str("no-world-readable"),
                                                      b(str("match"),
                                                        regular_expression
                                                      )
                                                  )
                                              ).as(:oneline),
                                              a(str("level"), arg),
                                              a(str("flag"), str("active-directory-authentication") | str("configuration") | str("db") | str("ip-user-mapping") | str("ip-user-probe") | str("ipc") | str("user-group-mapping") | str("wmic") | str("all")).as(:oneline)
                                          )
                                      ),
                                      b(a(str("domain"), arg),
                                          c(
                                              b(str("user"),
                                                  c(
                                                      a(str("user-name"), arg),
                                                      a(str("password"), arg)
                                                  )
                                              ),
                                              b(a(str("domain-controller"), arg),
                                                  c(
                                                      b(str("address"),
                                                        ipaddr
                                                      )
                                                  )
                                              ),
                                              b(str("ip-user-mapping"),
                                                  c(
                                                      b(str("discovery-method"),
                                                          c(
                                                              b(str("wmi"),
                                                                  c(
                                                                      a(str("event-log-scanning-interval"), arg),
                                                                      a(str("initial-event-log-timespan"), arg)
                                                                  )
                                                              )
                                                          )
                                                      )
                                                  )
                                              ),
                                              b(str("user-group-mapping"),
                                                user_group_mapping_type
                                              )
                                          )
                                      ),
                                      str("no-on-demand-probe"),
                                      a(str("authentication-entry-timeout"), arg),
                                      a(str("wmi-timeout"), arg),
                                      a(str("thread"), arg),
                                      a(str("event-log-identifier"), arg),
                                      a(str("logon-type"), arg),
                                      b(str("filter"),
                                          c(
                                              a(str("include"), arg).as(:oneline),
                                              a(str("exclude"), arg).as(:oneline)
                                          )
                                      )
                                  )
                              )
                          )
                      ),
                      b(str("ip-monitoring"),
                          c(
                              b(a(str("policy"), arg),
                                  c(
                                      str("no-preempt"),
                                      b(str("match"),
                                          c(
                                              a(str("rpm-probe"), arg)
                                          )
                                      ),
                                      b(str("then"),
                                        action_object_type
                                      )
                                  )
                              ),
                              b(str("traceoptions"),
                                  c(
                                      str("no-remote-trace"),
                                      b(str("file"),
                                          sca(
                                              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"), str("debug") | str("configuration") | str("errors") | str("memory") | str("event") | str("all")).as(:oneline)
                                  )
                              )
                          )
                      ),
                      str("wireless-wan"),
                      b(str("captive-portal"),
                        juniper_services_captive_portal
                      )
                  )
              ),
              b(str("bridge-domains"),
                  c(
                      b(str("domain"),
                        juniper_bridge_domains
                      )
                  )
              ),
              str("fabric"),
              b(str("switch-options"),
                juniper_def_rtb_switch_options
              ),
              b(str("access-profile"),
                  c(
                      a(str("access-profile-name"), arg)
                  )
              ).as(:oneline),
              str("multi-chassis"),
              b(str("jsrc"),
                jsrc_partition_definition
              ),
              str("jsrc-partition").as(:oneline),
              b(str("applications"),
                  c(
                      b(str("application"),
                        application_object
                      ),
                      b(str("application-set"),
                        application_set_object
                      )
                  )
              ),
              b(str("schedulers"),
                  c(
                      b(str("scheduler"),
                        scheduler_object_type
                      )
                  )
              ),
              b(str("smtp"),
                  c(
                      b(str("primary-server"),
                          c(
                              b(str("address"),
                                ipv4addr
                              ),
                              c(
                                b(str("login"),
                                  login_object
                                )
                              )
                          )
                      ),
                      b(str("secondary-server"),
                          c(
                              b(str("address"),
                                ipv4addr
                              ),
                              c(
                                b(str("login"),
                                  login_object
                                )
                              )
                          )
                      ),
                      b(str("traceoptions"),
                          c(
                              a(str("flag"), str("IPC") | str("protocol-exchange") | str("configuration") | str("send-request") | str("all")).as(:oneline)
                          )
                      )
                  )
              ),
              str("poe"),
              str("wlan"),
              b(str("ethernet-switching-options"),
                juniper_ethernet_options
              ),
              b(str("vlans"),
                  c(
                      b(str("traceoptions"),
                          c(
                              a(str("flag"), str("all") | str("kernel") | str("change-events") | str("kernel-detail") | str("config-states"),
                                  c(
                                      str("disable")
                                  )
                              ).as(:oneline)
                          )
                      ),
                      vlan_type
                  )
              ),
              b(str("virtual-chassis"),
                c(
                  b(str("aliases"),
                    b(a(str("serial-number"), arg),
                      a(str("alias-name"), arg)
                    )
                  ),
                  str("auto-provisioned"),
                  b(str("auto-sw-update"),
                    b(arg,
                      a(str("package-name"), arg)
                    )
                  ),
                  a(str("fast-failover"), str("ge") | str("vcp disable") | str("xe")),
                  b(str("graceful-restart"),
                    str("disable")
                  ),
                  a(str("id"), arg),
                  b(str("mac-persistence-timer"),
                    (str("minutes") | str("disable"))
                  ),
                  b(a(str("member"), arg),
                    c(
                      a(str("location"), arg),
                      a(str("mastership-priority"), arg),
                      str("no-management-vlan"),
                      a(str("serial-number"), arg),
                      a(str("role"), str("line-card") | str("routing-engine"))
                    )
                  ),
                  str("no-split-detection"),
                  str("preprovisioned"),
                  b(str("traceoptions"),
                    c(
                      b(str("file"),
                        c(
                          a(str("files"), arg),
                          str("no-stamp"),
                          str("replace"),
                          a(str("size"), arg),
                          str("world-readable"),
                          str("no-world-readable"),
                          arg
                        )
                      ),
                      a(str("flag"), str("detail") | str("disable") | str("receive") | str("send"))
                    )
                  ),
                  b(str("vc-port"),
                    a(str("lag-hash"), str("packet-based") | str("source-port-based"))
                  ),
                  str("vcp-no-hold-time")
                )
              )
          )
    end

    rule(:action_object_type) do
        c(
            b(str("preferred-route"),
                c(
                    b(a(str("routing-instances"), arg),
                        c(
                            b(a(str("route"), arg),
                                c(
                                    b(str("next-hop"),
                                      ipaddr_or_interface
                                    ),
                                    a(str("metric"), arg)
                                )
                            )
                        )
                    ),
                    b(a(str("route"), arg),
                        c(
                            b(str("next-hop"),
                              ipaddr_or_interface
                            ),
                            a(str("preferred-metric"), arg)
                        )
                    )
                )
            ),
            b(a(str("interface"), arg),
                c(
                    c(
                      str("enable"),
                      str("disable")
                    )
                )
            )
        )
    end

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

    rule(:anti_spam_feature) do
        c(
            a(str("address-whitelist"), arg),
            a(str("address-blacklist"), arg),
            b(str("traceoptions"),
              anti_spam_traceoptions
            ),
            b(str("sbl"),
              sbl_type
            )
        )
    end

    rule(:anti_spam_traceoptions) do
        c(
            a(str("flag"), str("manager") | str("sbl") | str("all")).as(:oneline)
        )
    end

    rule(:anti_virus_feature) do
        c(
            b(str("mime-whitelist"),
                c(
                    a(str("list"), arg),
                    a(str("exception"), arg)
                )
            ),
            a(str("url-whitelist"), arg),
            a(str("type"), arg),
            b(str("traceoptions"),
              anti_virus_traceoptions
            ),
            str("kaspersky-lab-engine"),
            str("juniper-express-engine"),
            b(str("sophos-engine"),
                c(
                    a(str("sxl-timeout"), arg),
                    a(str("sxl-retry"), arg),
                    b(str("pattern-update"),
                      anti_virus_pattern_update
                    ),
                    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
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:anti_virus_notification_options) do
        c(
            b(str("virus-detection"),
                c(
                    a(str("type"), arg),
                    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(
                    a(str("type"), arg),
                    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_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)
                )
            ),
            b(str("proxy"),
                c(
                    a(str("server"), arg),
                    a(str("port"), arg),
                    a(str("username"), arg),
                    b(str("password"),
                      unreadable
                    )
                )
            ),
            a(str("url"), arg),
            a(str("interval"), arg),
            str("no-autoupdate")
        )
    end

    rule(:anti_virus_traceoptions) do
        c(
            a(str("flag"), 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(:anti_virus_trickling) do
        c(
            a(str("timeout"), arg)
        ).as(:oneline)
    end

    rule(:any_filter) do
      b(arg.as(:arg),
        c(
            str("interface-specific"),
            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"))
                              )
                            )
                        )
                    ),
                    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)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            a(str("count"), arg),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              a(str("next"), arg)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:application_object) do
      b(arg.as(:arg),
        c(
            a(str("application-protocol"), arg),
            a(str("protocol"), arg),
            a(str("source-port"), arg),
            a(str("destination-port"), arg),
            a(str("ether-type"), arg),
            a(str("snmp-command"), arg),
            a(str("icmp-type"), arg),
            a(str("icmp6-type"), arg),
            a(str("icmp-code"), arg),
            a(str("icmp6-code"), arg),
            a(str("ttl-threshold"), arg),
            a(str("rpc-program-number"), arg),
            a(str("uuid"), arg),
            a(str("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")
            ),
            a(str("description"), quote | arg),
            b(str("term"),
              term_object
            )
        )
      )
    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"),
                c(
                    b(str("auth_key"),
                      unreadable
                    )
                )
            ).as(:oneline),
            a(str("switching-mode"), arg),
            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(
              a(str("request"), arg),
              a(str("force"), arg),
              str("lockout")
            )
        )
    end

    rule(:atm_policer_type) do
      b(arg.as(:arg),
        c(
            str("logical-interface-policer"),
            a(str("atm-service"), arg),
            a(str("peak-rate"), arg),
            a(str("sustained-rate"), arg),
            a(str("max-burst-size"), arg),
            a(str("cdvt"), arg),
            a(str("policing-action"), arg)
        )
      )
    end

    rule(:authentication_source_type) do
      b((str("local-authentication-table") | str("unified-access-control") | str("firewall-authentication") | str("active-directory-authentication-table")).as(:arg),
        c(
            c(
              a(str("priority"), arg)
            )
        )
      )
    end

    rule(:auto_configure_vlan_type) do
        c(
            b(str("stacked-vlan-ranges"),
                c(
                    b(a(str("dynamic-profile"), arg),
                        c(
                            b(str("accept"),
                                  (str("inet") | str("inet6") | str("pppoe") | str("dhcp-v4") | str("dhcp-v6") | str("any"))
                            ),
                            a(str("ranges"), arg)
                        )
                    ),
                    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"),
                        c(
                            a(str("access-profile-name"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("vlan-ranges"),
                c(
                    b(a(str("dynamic-profile"), arg),
                        c(
                            b(str("accept"),
                                  (str("inet") | str("inet6") | str("pppoe") | str("dhcp-v4") | str("dhcp-v6") | str("any"))
                            ),
                            a(str("ranges"), arg)
                        )
                    ),
                    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"),
                        c(
                            a(str("access-profile-name"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            str("remove-when-no-subscribers")
        )
    end

    rule(:auto_configure_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("option-82"),
                    str("circuit-type"),
                    a(str("radius-realm"), arg),
                    str("interface-name")
                )
            )
        )
    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"),
            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("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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | str("vrrp") | arg)
                              ),
                              b(str("ip-protocol-except"),
                                    (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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | 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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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
                            ),
                            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("two-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            a(str("count"), arg),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              a(str("next"), arg)
                            ),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("next-hop-group"), arg)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:category_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), 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("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("two-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            a(str("count"), arg),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("port-mirror-instance"), arg),
                            a(str("next-hop-group"), arg),
                            str("port-mirror"),
                            str("packet-mode"),
                            c(
                              str("accept"),
                              str("discard"),
                              a(str("next"), arg)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:certificate_object) do
      b(arg.as(:arg),
        c(
            a(str("certificate"), arg)
        )
      )
    end

    rule(:chassis_type) do
        c(
            str("nssu"),
            str("psu"),
            str("fpc-resync"),
            str("craft-lockout"),
            b(str("config-button"),
                c(
                    str("no-rescue"),
                    str("no-clear")
                )
            ).as(:oneline),
            str("packet-scheduling"),
            str("no-packet-scheduling"),
            str("policer-drop-probability-low"),
            str("memory-enhanced"),
            str("vrf-mtu-check"),
            a(str("maximum-ecmp"), arg),
            a(str("maximum-ecmp-32"), arg),
            b(str("redundancy"),
              chassis_redundancy_type
            ),
            b(str("routing-engine"),
              chassis_routing_engine_type
            ),
            b(str("aggregated-devices"),
              chassis_agg_dev_type
            ),
            b(str("container-devices"),
              chassisd_agg_container_type
            ),
            b(str("provider-instance-devices"),
              chassisd_provider_instance_type
            ),
            b(str("fpc"),
              chassis_fpc_type
            ),
            str("disable-power-management"),
            str("fpc-feb-connectivity"),
            str("ioc-npc-connectivity"),
            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("tfeb"),
              chassis_feb_type
            ),
            b(str("alarm"),
              chassis_alarm_type
            ),
            a(str("ppp-subscriber-services"), arg),
            a(str("network-services"), arg),
            str("usb"),
            b(a(str("node"), arg),
                c(
                    b(str("fpc"),
                      chassis_fpc_type
                    )
                )
            ),
            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")
                    )
                )
            ),
            str("member"),
            str("fabric"),
            str("synchronization"),
            str("lcd-menu"),
            a(str("fru-poweron-sequence"), arg),
            str("auto-image-upgrade"),
            str("route-localization"),
            str("state"),
            b(str("multicast-loadbalance"),
              chassis_ae_lb_type
            ),
            str("extended-statistics"),
            str("system-domains"),
            b(str("cluster"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sca(
                                    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"), str("cli") | str("configuration") | str("eventlib") | str("fsm") | str("heartbeat") | str("interface") | str("routing-socket") | str("uspipc") | str("init") | str("socket") | str("snmp") | str("ip-monitoring") | str("hw-monitoring") | str("fabric-monitoring") | str("schedule-monitoring") | str("heartbeat-tlv") | str("all")).as(:oneline),
                            a(str("level"), arg)
                        )
                    ),
                    str("control-link-recovery"),
                    a(str("reth-count"), arg),
                    str("control-ports").as(:oneline),
                    a(str("heartbeat-interval"), arg),
                    a(str("heartbeat-threshold"), arg),
                    str("network-management"),
                    b(a(str("redundancy-group"), arg),
                        c(
                            a(str("node"), str("0") | str("1"),
                                c(
                                    a(str("priority"), arg)
                                )
                            ).as(:oneline),
                            str("preempt"),
                            a(str("gratuitous-arp-count"), arg),
                            a(str("hold-down-interval"), arg),
                            b(a(str("interface-monitor"), arg),
                                c(
                                    a(str("weight"), arg)
                                )
                            ).as(:oneline),
                            b(str("ip-monitoring"),
                                c(
                                    a(str("global-weight"), arg),
                                    a(str("global-threshold"), arg),
                                    a(str("retry-interval"), arg),
                                    a(str("retry-count"), arg),
                                    b(str("family"),
                                        c(
                                            b(str("inet"),
                                                c(
                                                    b(str("address"),
                                                      ip_monitoring_address_type
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("configuration-synchronize"),
                        c(
                            str("no-secondary-bootup-auto")
                        )
                    )
                )
            ),
            b(str("forwarding-options"),
              c(
                b((str("l2-profile-one") | str("l2-profile-two") | str("l2-profile-three") | 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")
                  )
                )
              )
            )
        )
    end

    rule(:chassis_ae_lb_type) do
        c(
            a(str("hash-mode"), arg)
        )
    end

    rule(:chassis_agg_dev_type) do
        c(
            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("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
            )
        )
    end

    rule(:chassis_alarm_ds1_type) do
        c(
            a(str("ais"), arg),
            a(str("ylw"), arg)
        )
    end

    rule(:chassis_alarm_ds3_type) do
        c(
            a(str("ais"), arg),
            a(str("exz"), arg),
            a(str("ferf"), arg),
            a(str("idle"), arg),
            a(str("lcv"), arg),
            a(str("lof"), arg),
            a(str("los"), arg),
            a(str("pll"), arg),
            a(str("ylw"), arg)
        )
    end

    rule(:chassis_alarm_ethernet_type) do
        c(
            a(str("link-down"), arg)
        )
    end

    rule(:chassis_alarm_fibre_channel_type) do
        c(
            a(str("link-down"), arg)
        )
    end

    rule(:chassis_alarm_integrated_services_type) do
        c(
            a(str("failure"), arg)
        )
    end

    rule(:chassis_alarm_serial_type) do
        c(
            a(str("loss-of-rx-clock"), arg),
            a(str("loss-of-tx-clock"), arg),
            a(str("dcd-absent"), arg),
            a(str("cts-absent"), arg),
            a(str("dsr-absent"), arg),
            a(str("tm-absent"), arg)
        )
    end

    rule(:chassis_alarm_services_type) do
        c(
            a(str("pic-reset"), arg),
            a(str("pic-hold-reset"), arg),
            a(str("linkdown"), arg),
            a(str("rx-errors"), arg),
            a(str("tx-errors"), arg),
            a(str("sw-down"), arg),
            a(str("hw-down"), arg)
        )
    end

    rule(:chassis_alarm_sonet_type) do
        c(
            a(str("lol"), arg),
            a(str("pll"), arg),
            a(str("lof"), arg),
            a(str("los"), arg),
            a(str("ais-l"), arg),
            a(str("ais-p"), arg),
            a(str("lop-p"), arg),
            a(str("ber-sd"), arg),
            a(str("ber-sf"), arg),
            a(str("rfi-l"), arg),
            a(str("rfi-p"), arg),
            a(str("uneq-p"), arg),
            a(str("locd"), arg),
            a(str("plm-p"), arg)
        )
    end

    rule(:chassis_feb_type) do
        c(
            b(a(str("slot"), arg),
              a(str("sampling-instance"), arg)
            )
        )
    end

    rule(:chassis_fpc_type) do
      b(arg.as(:arg),
        c(
            a(str("error"), str("fatal") | str("major") | str("minor"),
              c(
                a(str("threshold"), arg),
                a(str("action"), str("alarm") | str("disable-pfe") | str("offline-pic") | str("log") | str("get-state") | str("offline") | str("reset"))
              )
            ),
            str("sanity-poll"),
            b(str("pic"),
              chassis_pic_type
            ),
            b(str("pfe"),
              chassis_pfe_type
            ),
            a(str("power"), arg),
            a(str("route-localization"), arg),
            a(str("power-budget-priority"), arg),
            c(
              str("allow-sram-parity-errors")
            ),
            str("offline"),
            str("offline-on-fabric-bandwidth-reduction"),
            str("port-mirror-instance"),
            a(str("sampling-instance"), arg),
            b(str("inline-services"),
              a(str("bandwidth"), str("1g") | str("10g"))
            ),
            a(str("number-of-ports"), arg)
        )
      )
    end

    rule(:chassis_pem_type) do
        c(
            a(str("minimum"), arg),
            a(str("feeds"), arg)
        )
    end

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

    rule(:chassis_pic_type) do
      b(arg.as(:arg),
        c(
            b(str("tunnel-port"),
              chassis_port_type
            ),
            b(str("tunnel-services"),
              c(
                a(str("bandwidth"), str("1g") | str("10g") | str("20g") | str("40g")).as(:oneline),
                str("tunnel-only")
              )
            ),
            b(str("inline-services"),
              a(str("bandwidth"), str("1g") | str("10g"))
            ),
            c(
              str("adaptive-services"),
              str("monitoring-services")
            ),
            str("no-mcast-replication"),
            a(str("framing"), arg),
            str("synchronization"),
            str("recovered-clock"),
            a(str("vtmapping"), arg),
            str("no-concatenate"),
            str("no-multi-rate"),
            str("channelization"),
            str("linerate-mode"),
            str("no-pre-classifier"),
            str("aggregate-ports"),
            str("aggregated-devices"),
            str("sparse-dlcis"),
            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),
                    a(str("mode"), arg)
                )
            ),
            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"),
            str("services-offload"),
            a(str("mlfr-uni-nni-bundles"), arg),
            b(str("ct3"),
                c(
                    b(str("port"),
                      ct3_port_type
                    )
                )
            ),
            b(str("ce1"),
                c(
                    b(str("e1"),
                      ce1_channel_type
                    )
                )
            ),
            a(str("max-queues-per-interface"), arg),
            b(str("shdsl"),
                c(
                    a(str("pic-mode"), arg)
                )
            ),
            b(str("ethernet"),
                c(
                    a(str("pic-mode"), arg)
                )
            ),
            str("tunnel-queuing"),
            a(str("port-mirror-instance"), arg),
            b(str("port"),
              chassis_pic_port_framing
            ),
            b(str("fibre-channel"),
              chassis_fibre_channel_type
            ),
            str("sfpplus"),
            str("hash-key"),
            a(str("ingress-policer-overhead"), arg),
            a(str("egress-policer-overhead"), arg),
            str("forwarding-mode")
        )
      )
    end

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

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

    rule(:chassis_pic_port_framing) do
      b(arg.as(:arg),
        c(
            a(str("framing"), arg),
            a(str("speed"), arg),
            a(str("channel-speed"), str("10g") | str("25g") | str("50g") | str("100g") | str("disable-auto-speed-detection"))
        )
      )
    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),
            b(str("graceful-switchover"),
              chassis_non_stop_forwarding_type
            ),
            str("feb")
        )
    end

    rule(:chassis_non_stop_forwarding_type) do

    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-disk-failure")
        )
    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
            ),
            str("control-interface"),
            str("bios"),
            str("usb-wwan")
        )
    end

    rule(:chassis_re_on_disk_failure) do
        c(
            c(
              a(str("disk-failure-action"), arg)
            )
        ).as(:oneline)
    end

    rule(:chassis_sfm_type) do
      b(arg.as(:arg),
        c(
            a(str("power"), arg)
        )
      )
    end

    rule(:chassis_sib_type) do
        c(
            a(str("minimum"), arg),
            str("power-off")
        )
    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(:command_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), arg)
        )
      )
    end

    rule(:content_filtering_feature) do
        c(
            b(str("traceoptions"),
              content_filtering_traceoptions
            ),
            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(
                            a(str("type"), arg),
                            str("notify-mail-sender"),
                            str("no-notify-mail-sender"),
                            a(str("custom-message"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:content_filtering_traceoptions) do
        c(
            a(str("flag"), str("basic") | str("detail") | str("all")).as(:oneline)
        )
    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"), str("low") | str("high")).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),
                c(
                    a(str("timeslots"), arg)
                )
            ).as(:oneline)
        )
      )
    end

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

    rule(:custom_attack_type) do
      b(arg.as(:arg),
        c(
            a(str("recommended-action"), arg),
            a(str("severity"), arg),
            b(str("time-binding"),
                c(
                    a(str("count"), arg),
                    a(str("scope"), 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("icmp"),
                                      str("icmpv6"),
                                      b(str("ip"),
                                          c(
                                              a(str("protocol-number"), arg)
                                          )
                                      ),
                                      b(str("ipv6"),
                                          c(
                                              a(str("protocol-number"), arg)
                                          )
                                      ),
                                      a(str("application"), arg)
                                    )
                                )
                            ),
                            a(str("context"), arg),
                            a(str("pattern"), arg),
                            a(str("regexp"), arg),
                            str("negate"),
                            a(str("direction"), arg),
                            a(str("shellcode"), arg),
                            b(str("protocol"),
                                c(
                                    b(str("ipv4"),
                                        c(
                                            b(str("tos"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("total-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ip-flags"),
                                                c(
                                                    str("rb"),
                                                    str("no-rb"),
                                                    str("mf"),
                                                    str("no-mf"),
                                                    str("df"),
                                                    str("no-df")
                                                )
                                            ).as(:oneline),
                                            b(str("ttl"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("protocol"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("source"),
                                                c(
                                                    a(str("match"), arg),
                                                    b(str("value"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    a(str("match"), arg),
                                                    b(str("value"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("ipv6"),
                                        c(
                                            b(str("traffic-class"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("payload-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("flow-label"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("hop-limit"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("next-header"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("source"),
                                                c(
                                                    a(str("match"), arg),
                                                    b(str("value"),
                                                      ipv6addr
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    a(str("match"), arg),
                                                    b(str("value"),
                                                      ipv6addr
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("tcp"),
                                        c(
                                            b(str("source-port"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("destination-port"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ack-number"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("header-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("window-size"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("urgent-pointer"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("tcp-flags"),
                                                c(
                                                    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(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("window-scale"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("mss"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("udp"),
                                        c(
                                            b(str("source-port"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("destination-port"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("icmp"),
                                        c(
                                            b(str("type"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("code"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    str("icmpv6")
                                )
                            )
                        )
                    ),
                    b(str("anomaly"),
                        c(
                            a(str("service"), arg),
                            a(str("test"), arg),
                            a(str("direction"), arg),
                            a(str("shellcode"), arg)
                        )
                    ),
                    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("icmp"),
                                      str("icmpv6"),
                                      b(str("ip"),
                                          c(
                                              a(str("protocol-number"), arg)
                                          )
                                      ),
                                      b(str("ipv6"),
                                          c(
                                              a(str("protocol-number"), arg)
                                          )
                                      ),
                                      a(str("application"), arg)
                                    )
                                )
                            ),
                            a(str("scope"), arg),
                            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("regexp"), arg),
                            str("negate"),
                            a(str("direction"), arg),
                            a(str("shellcode"), arg),
                            b(str("protocol"),
                                c(
                                    b(str("ipv4"),
                                        c(
                                            b(str("tos"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("total-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ip-flags"),
                                                c(
                                                    str("rb"),
                                                    str("no-rb"),
                                                    str("mf"),
                                                    str("no-mf"),
                                                    str("df"),
                                                    str("no-df")
                                                )
                                            ).as(:oneline),
                                            b(str("ttl"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("protocol"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("source"),
                                                c(
                                                    a(str("match"), arg),
                                                    b(str("value"),
                                                      ipv4addr
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    a(str("match"), arg),
                                                    b(str("value"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("ipv6"),
                                        c(
                                            b(str("traffic-class"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("payload-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("flow-label"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("hop-limit"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("next-header"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("source"),
                                                c(
                                                    a(str("match"), arg),
                                                    b(str("value"),
                                                      ipv6addr
                                                    )
                                                )
                                            ),
                                            b(str("destination"),
                                                c(
                                                    a(str("match"), arg),
                                                    b(str("value"),
                                                      ipv6addr
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(str("tcp"),
                                        c(
                                            b(str("source-port"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("destination-port"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("ack-number"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("header-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("window-size"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("urgent-pointer"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("tcp-flags"),
                                                c(
                                                    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(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("window-scale"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("mss"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("udp"),
                                        c(
                                            b(str("source-port"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("destination-port"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("icmp"),
                                        c(
                                            b(str("type"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("code"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("identification"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("sequence-number"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            ),
                                            b(str("data-length"),
                                                c(
                                                    a(str("match"), arg),
                                                    a(str("value"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    str("icmpv6")
                                )
                            )
                        )
                    ),
                    b(str("anomaly"),
                        c(
                            a(str("test"), arg),
                            a(str("direction"), arg),
                            a(str("shellcode"), arg)
                        )
                    )
                )
            )
        )
      )
    end

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

    rule(:dcd_shaping_config) do
        c(
            c(
              b(str("cbr"),
                  c(
                      a(str("cbr-value"), arg),
                      a(str("cdvt"), arg)
                  )
              ).as(:oneline),
              b(str("vbr"),
                  c(
                      a(str("peak"), arg),
                      a(str("sustained"), arg),
                      a(str("burst"), arg),
                      a(str("cdvt"), arg)
                  )
              ).as(:oneline),
              b(str("rtvbr"),
                  c(
                      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(
            a(str("overflow"), arg),
            a(str("rate"), arg),
            a(str("threshold"), arg)
        )
    end

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

    rule(:dhcp_client_type) do
        c(
            b(str("client-identifier"),
                c(
                    b(str("user-id"),
                        c(
                            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")
                        )
                    ),
                    a(str("use-interface-description"), arg)
                )
            ).as(:oneline),
            a(str("lease-time"), arg),
            a(str("retransmission-attempt"), arg),
            a(str("retransmission-interval"), arg),
            b(str("server-address"),
              ipv4addr
            ),
            str("update-server"),
            a(str("vendor-id"), arg)
        )
    end

    rule(:dynamic_attack_group_type) do
      b(arg.as(:arg),
        c(
            b(str("filters"),
                c(
                    b(str("direction"),
                        c(
                            a(str("expression"), arg),
                            a(str("values"), arg)
                        )
                    ),
                    b(str("severity"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    b(str("type"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    str("recommended"),
                    str("no-recommended"),
                    b(str("performance"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    b(str("category"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    b(str("service"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    b(str("false-positives"),
                        c(
                            a(str("values"), arg)
                        )
                    ),
                    b(str("products"),
                        c(
                            a(str("values"), arg)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:dynamic_ifbw_parms_type) do
        c(
            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(:epd_threshold_config) do
        c(
            a(str("epd-threshold-plp0"), arg),
            a(str("plp1"), arg)
        ).as(:oneline)
    end

    rule(:ethernet_switching_type) do
        c(
            a(str("port-mode"), str("access") | str("trunk")),
            a(str("interface-mode"), str("access") | str("trunk")),
            str("reflective-relay"),
            b(str("vlan"),
                c(
                    a(str("members"), str("all") | arg)
                )
            ),
            a(str("native-vlan-id"), arg),
            b(str("filter"),
                c(
                    a(str("input"), arg),
                    a(str("output"), arg)
                )
            ),
            b(str("storm-control"),
              storm_control
            )
        )
    end

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

    rule(:extension_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), arg)
        )
      )
    end

    rule(:fibre_channel_type) do
        c(
            a(str("port-mode"), arg),
            str("no-npiv"),
            b(str("fc-fabric"),
                c(
                    a(str("members"), arg)
                )
            ),
            a(str("native-fabric"), arg)
        )
    end

    rule(:firewall_addr_object) do
      b(arg.as(:arg),
        c(
            str("except")
        )
      ).as(:oneline)
    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"),
            b(str("if-exceeding"),
                c(
                    c(
                      a(str("bandwidth-limit"), arg),
                      a(str("bandwidth-percent"), arg)
                    ),
                    a(str("burst-size-limit"), arg)
                )
            ),
            b(str("then"),
                c(
                    str("discard"),
                    a(str("loss-priority"), arg),
                    a(str("forwarding-class"), arg),
                    str("out-of-profile")
                )
            )
        )
      )
    end

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

    rule(:flow_filter_type) do
      b(arg.as(:arg),
        c(
            a(str("protocol"), arg),
            b(str("source-prefix"),
              ipprefix
            ),
            b(str("destination-prefix"),
              ipprefix
            ),
            a(str("logical-system"), arg),
            a(str("source-port"), arg),
            a(str("destination-port"), arg),
            b(str("interface"),
              interface_name
            )
        )
      )
    end

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

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

    rule(:host_object) do
        c(
            b(str("ipaddr"),
              ipaddr
            ),
            a(str("port"), 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(
                                    a(str("from-zone"), arg),
                                    c(
                                      a(str("source-address"), arg),
                                      a(str("source-except"), arg),
                                      str("source-prefix"),
                                      str("source-prefix-except")
                                    ),
                                    a(str("to-zone"), arg),
                                    c(
                                      a(str("destination-address"), arg),
                                      a(str("destination-except"), arg),
                                      str("destination-prefix"),
                                      str("destination-prefix-except")
                                    ),
                                    a(str("application"), 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(
                                                      a(str("codepoint"), arg)
                                                  )
                                              ),
                                              str("class-of-service"),
                                              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")
                                            ),
                                            a(str("target"), arg),
                                            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)
                                                )
                                            )
                                        )
                                    ),
                                    a(str("severity"), arg)
                                )
                            ),
                            str("terminal")
                        )
                    )
                )
            ),
            b(str("rulebase-exempt"),
                c(
                    b(a(str("rule"), arg),
                        c(
                            a(str("description"), quote | arg),
                            b(str("match"),
                                c(
                                    a(str("from-zone"), arg),
                                    c(
                                      a(str("source-address"), arg),
                                      a(str("source-except"), arg),
                                      str("source-prefix"),
                                      str("source-prefix-except")
                                    ),
                                    a(str("to-zone"), arg),
                                    c(
                                      a(str("destination-address"), arg),
                                      a(str("destination-except"), arg),
                                      str("destination-prefix"),
                                      str("destination-prefix-except")
                                    ),
                                    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"),
                sca(
                    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"), str("all")).as(:oneline),
            a(str("level"), arg)
        )
    end

    rule(:ids_option_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            str("alarm-without-drop"),
            b(str("icmp"),
                c(
                    b(str("ip-sweep"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    str("fragment"),
                    str("large"),
                    b(str("flood"),
                        c(
                            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),
                                        c(
                                            b(str("to"),
                                                c(
                                                    a(str("type-high"), 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),
                                        c(
                                            b(str("to"),
                                                c(
                                                    a(str("type-high"), arg)
                                                )
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            str("shim6-header"),
                            str("mobility-header"),
                            str("HIP-header"),
                            b(a(str("user-defined-header-type"), arg),
                                c(
                                    b(str("to"),
                                        c(
                                            a(str("type-high"), arg)
                                        )
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    a(str("ipv6-extension-header-limit"), arg),
                    str("ipv6-malformed-header")
                )
            ),
            b(str("tcp"),
                c(
                    str("syn-fin"),
                    str("fin-no-ack"),
                    str("tcp-no-flag"),
                    str("syn-frag"),
                    b(str("port-scan"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    b(str("syn-ack-ack-proxy"),
                        c(
                            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("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"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("udp"),
                c(
                    b(str("flood"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    b(str("udp-sweep"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline),
                    b(str("port-scan"),
                        c(
                            a(str("threshold"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("limit-session"),
                c(
                    a(str("source-ip-based"), arg),
                    a(str("destination-ip-based"), 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("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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | str("vrrp") | arg)
                              ),
                              b(str("next-header-except"),
                                    (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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | 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("range"))
                              ),
                              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("range"))
                              )
                            ),
                            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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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(:firewall_addr6_object) do
      b(arg.as(:arg),
        c(
            str("except")
        )
      ).as(:oneline)
    end

    rule(:inet6_filter) do
      b(arg.as(:arg),
        c(
            a(str("accounting-profile"), arg),
            str("interface-specific"),
            str("enhanced-mode"),
            str("physical-interface-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),
                              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("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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | str("vrrp") | arg)
                              ),
                              b(str("next-header-except"),
                                    (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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | 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(
                              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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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("range"))
                              ),
                              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("range"))
                              )
                            ),
                            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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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)
                            )
                        )
                    ),
                    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)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            a(str("count"), arg),
                            str("service-accounting"),
                            str("log"),
                            str("syslog"),
                            str("sample"),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("analyzer"), arg),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            str("service-filter-hit"),
                            c(
                              str("accept"),
                              str("discard"),
                              a(str("traffic-class"), arg),
                              a(str("next"), arg),
                              b(str("logical-system"),
                                  s(
                                    a(str("logical-system-name"), arg),
                                    c(
                                      b(str("routing-instance"),
                                          c(
                                              a(str("routing-instance-name"), arg),
                                              a(str("topology"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("topology"), arg)
                                    )
                                  )
                              ).as(:oneline),
                              b(str("routing-instance"),
                                  c(
                                      a(str("routing-instance-name"), arg),
                                      a(str("topology"), arg)
                                  )
                              ).as(:oneline),
                              a(str("topology"), arg),
                              b(str("reject"),
                                  c(
                                      c(
                                        str("no-route"),
                                        str("administratively-prohibited"),
                                        str("beyond-scope"),
                                        str("address-unreachable"),
                                        str("port-unreachable"),
                                        str("tcp-reset"),
                                        str("fragmentation-needed")
                                      )
                                  )
                              ).as(:oneline)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet6_fuf) do
      b(arg.as(:arg),
        c(
            str("interface-specific"),
            b(str("match-order"),
                  (str("next-header") | 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("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"),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("action-terms"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              b(str("routing-instance"),
                                  c(
                                      a(str("routing-instance-name"), arg),
                                      a(str("topology"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:firewall_addr6_simple_object) do
        c(
            b(str("address"),
              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("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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | str("vrrp") | arg)
                              ),
                              b(str("next-header-except"),
                                    (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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | 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(
                              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)
                        )
                    ),
                    b(str("then"),
                        c(
                            a(str("count"), arg),
                            str("log"),
                            str("sample"),
                            str("port-mirror"),
                            c(
                              str("service"),
                              str("skip")
                            )
                        )
                    )
                )
            )
        )
      )
    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") | str("range"))
                              ),
                              b(str("precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | str("range"))
                              )
                            ),
                            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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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("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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | str("vrrp") | arg)
                              ),
                              b(str("protocol-except"),
                                    (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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | 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(
            a(str("accounting-profile"), arg),
            str("interface-specific"),
            str("physical-interface-filter"),
            str("enhanced-mode"),
            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),
                              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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            c(
                              b(str("precedence"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | str("range"))
                              ),
                              b(str("precedence-except"),
                                    (str("net-control") | str("internet-control") | str("critical-ecp") | str("flash-override") | str("flash") | str("immediate") | str("priority") | str("routine") | str("range"))
                              )
                            ),
                            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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            str("is-fragment"),
                            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("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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | str("vrrp") | arg)
                              ),
                              b(str("protocol-except"),
                                    (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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | 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"))
                              )
                            )
                        )
                    ),
                    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)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            a(str("count"), arg),
                            str("service-accounting"),
                            str("log"),
                            str("packet-mode"),
                            str("syslog"),
                            str("sample"),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("analyzer"), arg),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            str("service-filter-hit"),
                            a(str("virtual-channel"), arg),
                            c(
                              str("accept"),
                              b(str("discard"),
                                  c(
                                      a(str("accounting"), arg)
                                  )
                              ),
                              a(str("next"), arg),
                              b(str("logical-system"),
                                  s(
                                    a(str("logical-system-name"), arg),
                                    c(
                                      b(str("routing-instance"),
                                          c(
                                              a(str("routing-instance-name"), arg),
                                              a(str("topology"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("topology"), arg)
                                    )
                                  )
                              ).as(:oneline),
                              b(str("routing-instance"),
                                  c(
                                      a(str("routing-instance-name"), arg),
                                      a(str("topology"), arg)
                                  )
                              ).as(:oneline),
                              a(str("topology"), arg),
                              a(str("ipsec-sa"), arg),
                              a(str("next-hop-group"), arg),
                              b(str("reject"),
                                  c(
                                      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)
                            ),
                            a(str("dscp"), arg),
                            a(str("prefix-action"), 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"),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            a(str("action-terms"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              b(str("routing-instance"),
                                  c(
                                      a(str("routing-instance-name"), arg),
                                      a(str("topology"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:firewall_addr_simple_object) do
        c(
            b(str("address"),
              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("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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | str("vrrp") | arg)
                              ),
                              b(str("protocol-except"),
                                    (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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | 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"))
                              )
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            a(str("count"), arg),
                            str("log"),
                            str("sample"),
                            str("port-mirror"),
                            c(
                              str("service"),
                              str("skip")
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:inet_simple_filter) do
      b(arg.as(:arg),
        c(
            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)
                                      )
                                  )
                              )
                            ),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            str("discard"),
                            str("accept")
                        )
                    )
                )
            )
        )
      )
    end

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

    rule(:interfaces_type) do
      b((arg | str("interface-name")).as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("metadata"), arg),
            c(
              str("disable")
            ),
            str("promiscuous-mode"),
            a(str("port-mirror-instance"), arg),
            str("multicast-statistics"),
            b(str("fabric-options"),
                c(
                    a(str("member-interfaces"), arg)
                )
            ),
            b(str("traceoptions"),
                c(
                    a(str("flag"), str("ipc") | str("event") | str("media") | str("all") | str("q921") | str("q931")).as(:oneline),
                    b(str("file"),
                        sca(
                            a(str("size"), arg),
                            a(str("files"), arg),
                            str("world-readable"),
                            str("no-world-readable")
                        )
                    )
                )
            ),
            str("passive-monitor-mode"),
            c(
              b(str("keepalives"),
                keepalives_type
              ).as(:oneline),
              str("no-keepalives")
            ),
            str("traps"),
            str("no-traps"),
            a(str("accounting-profile"), arg),
            c(
              str("per-unit-scheduler"),
              str("no-per-unit-scheduler"),
              str("shared-scheduler"),
              b(str("hierarchical-scheduler"),
                  c(
                      a(str("maximum-hierarchy-levels"), arg)
                  )
              ).as(:oneline)
            ),
            a(str("schedulers"), arg),
            str("interface-transmit-statistics"),
            str("dce"),
            c(
              str("vlan-tagging"),
              str("stacked-vlan-tagging"),
              str("flexible-vlan-tagging"),
              str("vlan-vci-tagging")
            ),
            a(str("native-vlan-id"), arg),
            a(str("speed"), 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("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)
                )
            ),
            str("ima-group-options"),
            str("ima-link-options"),
            b(str("multi-chassis-protection"),
              multi_chassis_protection_group
            ),
            b(str("clocking"),
                c(
                    c(
                      str("internal"),
                      b(str("external"),
                          c(
                              b(str("interface"),
                                interface_device
                              )
                          )
                      )
                    )
                )
            ).as(:oneline),
            a(str("link-mode"), arg),
            a(str("media-type"), arg),
            a(str("encapsulation"), arg),
            b(str("framing"),
                c(
                    c(
                      str("lan-phy"),
                      str("wan-phy"),
                      str("sonet"),
                      str("sdh")
                    )
                )
            ),
            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),
                    a(str("lmi-type"), arg)
                )
            ),
            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),
                    a(str("action-red-differential-delay"), arg),
                    a(str("fragment-threshold"), arg),
                    a(str("drop-timeout"), arg),
                    b(str("link-layer-overhead"),
                      unsigned_float
                    ),
                    a(str("lmi-type"), arg),
                    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_unicaset
            ),
            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(
                    str("per-unit-mac-disable")
                )
            ),
            b(str("aggregated-sonet-options"),
                c(
                    a(str("minimum-links"), arg),
                    a(str("link-speed"), arg),
                    a(str("minimum-bandwidth"), arg)
                )
            ),
            b(str("atm-options"),
                c(
                    a(str("pic-type"), arg),
                    a(str("cell-bundle-size"), 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"),
                                c(
                                    c(
                                      a(str("oam-period"), arg),
                                      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),
                        c(
                            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(
                            a(str("vc-cos-mode"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("priority"), arg),
                                    b(str("transmit-weight"),
                                        c(
                                            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"),
                    b(str("flow-control-options"),
                        c(
                            str("dump-on-flow-control"),
                            str("reset-on-flow-control"),
                            str("down-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
            ),
            str("redundancy-options"),
            str("load-balancing-options"),
            str("lsq-failure-options"),
            b(str("services-options"),
                c(
                    b(str("syslog"),
                      service_set_syslog_object
                    ),
                    a(str("open-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),
                    str("trio-flow-offload"),
                    str("cgn-pic"),
                    b(str("session-limit"),
                        c(
                            a(str("maximum"), arg),
                            a(str("rate"), arg)
                        )
                    ),
                    b(str("ignore-errors"),
                        c(
                            str("tcp"),
                            str("alg")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("t3-options"),
                c(
                    a(str("loopback"), arg),
                    str("long-buildout"),
                    str("no-long-buildout"),
                    str("loop-timing"),
                    str("no-loop-timing"),
                    str("unframed"),
                    str("no-unframed"),
                    b(str("compatibility-mode"),
                        c(
                            c(
                              b(str("larscom"),
                                  c(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("verilink"),
                                  c(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("adtran"),
                                  c(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("kentrox"),
                                  c(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("digital-link"),
                                  c(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    str("payload-scrambler"),
                    str("no-payload-scrambler"),
                    str("cbit-parity"),
                    str("no-cbit-parity"),
                    a(str("fcs"), arg),
                    a(str("idle-cycle-flag"), arg),
                    a(str("start-end-flag"), arg),
                    str("feac-loop-respond"),
                    str("no-feac-loop-respond"),
                    a(str("bert-algorithm"), arg),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg),
                    a(str("buildout"), arg),
                    a(str("atm-encapsulation"), arg)
                )
            ),
            b(str("e3-options"),
                c(
                    a(str("loopback"), arg),
                    str("unframed"),
                    str("no-unframed"),
                    b(str("compatibility-mode"),
                        c(
                            c(
                              str("larscom"),
                              b(str("digital-link"),
                                  c(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline),
                              b(str("kentrox"),
                                  c(
                                      a(str("subrate"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    str("payload-scrambler"),
                    str("no-payload-scrambler"),
                    a(str("fcs"), arg),
                    a(str("idle-cycle-flag"), arg),
                    str("invert-data"),
                    a(str("start-end-flag"), arg),
                    a(str("bert-algorithm"), arg),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg),
                    a(str("buildout"), arg),
                    a(str("atm-encapsulation"), arg),
                    a(str("framing"), arg)
                )
            ),
            b(str("e1-options"),
                c(
                    a(str("timeslots"), arg),
                    a(str("loopback"), arg),
                    a(str("framing"), arg),
                    a(str("fcs"), arg),
                    str("invert-data"),
                    a(str("idle-cycle-flag"), arg),
                    a(str("start-end-flag"), arg),
                    a(str("bert-algorithm"), arg),
                    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),
                    a(str("loopback"), arg),
                    a(str("buildout"), arg),
                    a(str("byte-encoding"), arg),
                    a(str("line-encoding"), arg),
                    str("invert-data"),
                    a(str("framing"), arg),
                    a(str("fcs"), arg),
                    a(str("idle-cycle-flag"), arg),
                    a(str("start-end-flag"), arg),
                    a(str("bert-algorithm"), arg),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg),
                    str("remote-loopback-respond"),
                    a(str("crc-major-alarm-threshold"), arg),
                    a(str("crc-minor-alarm-threshold"), arg),
                    a(str("alarm-compliance"), arg)
                )
            ),
            b(str("ds0-options"),
                c(
                    a(str("loopback"), arg),
                    a(str("byte-encoding"), arg),
                    str("invert-data"),
                    a(str("fcs"), arg),
                    a(str("idle-cycle-flag"), arg),
                    a(str("start-end-flag"), arg),
                    a(str("bert-algorithm"), arg),
                    a(str("bert-error-rate"), arg),
                    a(str("bert-period"), arg)
                )
            ),
            b(str("serial-options"),
                c(
                    a(str("line-protocol"), arg),
                    c(
                      b(str("dte-options"),
                          c(
                              str("ignore-all"),
                              b(str("dtr"),
                                  c(
                                      c(
                                        str("assert"),
                                        str("de-assert"),
                                        str("normal"),
                                        b(str("auto-synchronize"),
                                            c(
                                                a(str("duration"), arg),
                                                a(str("interval"), arg)
                                            )
                                        )
                                      )
                                  )
                              ).as(:oneline),
                              a(str("control-signal"), arg),
                              a(str("rts"), arg),
                              a(str("dcd"), arg),
                              a(str("dsr"), arg),
                              a(str("cts"), arg),
                              a(str("indication"), arg),
                              a(str("tm"), arg)
                          )
                      ),
                      b(str("dce-options"),
                          c(
                              str("ignore-all"),
                              a(str("dtr"), arg),
                              a(str("rts"), arg),
                              a(str("dcd"), arg),
                              a(str("dsr"), arg),
                              a(str("cts"), arg),
                              a(str("tm"), arg),
                              str("dce-loopback-override")
                          )
                      )
                    ),
                    a(str("dtr-circuit"), arg),
                    a(str("dtr-polarity"), arg),
                    a(str("rts-polarity"), arg),
                    a(str("control-polarity"), arg),
                    a(str("dcd-polarity"), arg),
                    a(str("dsr-polarity"), arg),
                    a(str("cts-polarity"), arg),
                    a(str("indication-polarity"), arg),
                    a(str("tm-polarity"), arg),
                    a(str("clocking-mode"), arg),
                    a(str("transmit-clock"), arg),
                    a(str("clock-rate"), arg),
                    a(str("loopback"), arg),
                    a(str("encoding"), arg),
                    a(str("idle-cycle-flag"), arg)
                )
            ),
            str("gratuitous-arp-reply"),
            str("no-gratuitous-arp-reply"),
            str("no-gratuitous-arp-request"),
            str("no-no-gratuitous-arp-request"),
            str("fibrechannel-options"),
            b(str("ether-options") | str("gigether-options"),
                c(
                    str("loopback"),
                    str("no-loopback"),
                    str("flow-control"),
                    str("no-flow-control"),
                    str("source-filtering"),
                    str("no-source-filtering"),
                    c(
                      str("no-auto-negotiation"),
                      b(str("auto-negotiation"),
                          c(
                              a(str("remote-fault"), arg)
                          )
                      ).as(:oneline)
                    ),
                    a(str("mac-mode"), arg),
                    str("asynchronous-notification"),
                    a(str("source-address-filter"), arg).as(:oneline),
                    b(str("redundant-parent"),
                        c(
                            b(str("parent"),
                              interface_device
                            )
                        )
                    ),
                    b(str("802.3ad"),
                      ca(
                        b(str("lacp"),
                          c(
                            str("force-up"),
                                    a(str("port-priority"), arg)
                                )
                            ),
                            b(str("bundle"),
                              interface_device
                            ),
                            a(str("link-index"), arg),
                            c(
                              str("primary"),
                              str("backup")
                            )
                        )
                    ),
                    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
                                    )
                                )
                            ),
                            str("mac-learn-enable"),
                            str("no-mac-learn-enable")
                        )
                    ),
                    b(str("mpls"),
                      mpls_ifd_options
                    ),
                    str("ignore-l3-incompletes"),
                    str("no-auto-mdix")
                )
            ),
            b(str("optics-options"),
                c(
                    a(str("wavelength"), arg),
                    a(str("alarm"), str("low-light-alarm"),
                        c(
                            c(
                              str("syslog"),
                              str("link-down")
                            )
                        )
                    ),
                    a(str("warning"), str("low-light-warning"),
                        c(
                            c(
                              str("syslog"),
                              str("link-down")
                            )
                        )
                    )
                )
            ),
            b(str("otn-options"),
              otn_options_type
            ),
            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(
                            b(str("parent"),
                              interface_device
                            )
                        )
                    ),
                    b(str("802.3ad"),
                      ca(
                        b(str("lacp"),
                          c(
                            str("force-up"),
                                    a(str("port-priority"), arg)
                                )
                            ),
                            b(str("bundle"),
                              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),
                    a(str("link-speed"), arg),
                    a(str("minimum-links"), arg),
                    b(str("lacp"),
                        c(
                            c(
                              str("active"),
                              str("passive")
                            ),
                            a(str("periodic"), arg)
                        )
                    )
                )
            ),
            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("link-protection"),
                    str("no-link-protection"),
                    str("source-address-filter").as(:oneline),
                    a(str("minimum-links"), arg),
                    str("logical-interface-fpc-redundancy"),
                    b(str("rebalance-periodic"),
                        c(
                            b(str("start-time"),
                              time
                            ),
                            a(str("interval"), arg)
                        )
                    ),
                    a(str("link-speed"), arg),
                    b(str("lacp"),
                        c(
                            c(
                              str("active"),
                              str("passive")
                            ),
                            a(str("periodic"), arg),
                            b(str("link-protection"),
                                c(
                                    str("disable"),
                                    c(
                                      str("revertive"),
                                      str("non-revertive")
                                    )
                                )
                            ),
                            a(str("system-priority"), arg),
                            b(str("system-id"),
                              mac_addr
                            ),
                            a(str("admin-key"), arg)
                        )
                    ),
                    b(str("ethernet-switch-profile"),
                        c(
                            a(str("tag-protocol-id"), arg)
                        )
                    ),
                    str("mc-ae")
                )
            ),
            b(str("es-options"),
                c(
                    b(str("backup-interface"),
                      interface_device
                    )
                )
            ),
            b(str("dsl-options"),
                c(
                    a(str("operating-mode"), arg)
                )
            ),
            b(str("vdsl-options"),
                c(
                    a(str("vdsl-profile"), arg)
                )
            ),
            b(str("shdsl-options"),
                c(
                    a(str("annex"), arg),
                    a(str("line-rate"), arg),
                    a(str("loopback"), arg),
                    b(str("snr-margin"),
                        c(
                            a(str("current"), arg),
                            a(str("snext"), 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"),
                            a(str("link-mode"), arg),
                            a(str("speed"), arg),
                            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(
                                      a(str("member-interface-speed"), arg)
                                  )
                              ),
                              b(str("atm"),
                                  c(
                                      a(str("member-interface-speed"), arg)
                                  )
                              )
                            )
                        )
                    ),
                    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("allow-configuration-override")
                )
            ),
            str("layer2-policer"),
            a(str("unit"), arg | arg | str("interface-unit-number"),
                c(
                    b(str("peer-psd"),
                        c(
                            a(str("psd-name"), arg)
                        )
                    ).as(:oneline),
                    b(str("peer-interface"),
                        c(
                            b(str("interface-name"),
                              interface_unit
                            )
                        )
                    ),
                    b(str("interface-shared-with"),
                        c(
                            a(str("psd-name"), arg)
                        )
                    ),
                    c(
                      str("disable")
                    ),
                    str("passive-monitor-mode"),
                    str("per-session-scheduler"),
                    str("clear-dont-fragment-bit"),
                    str("reassemble-packets"),
                    str("rpm"),
                    a(str("description"), quote | arg),
                    a(str("metadata"), arg),
                    str("dial-options"),
                    b(str("demux-source"),
                          (str("inet") | str("inet6"))
                    ),
                    b(str("demux-destination"),
                          (str("inet") | str("inet6"))
                    ),
                    a(str("encapsulation"), arg),
                    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"),
                    b(str("arp-resp"),
                        c(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    b(str("proxy-arp"),
                        c(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    c(
                      a(str("vlan-id"), arg),
                      a(str("vlan-id-range"), arg),
                      a(str("vlan-id-list"), arg),
                      b(str("vlan-tags"),
                          c(
                              a(str("outer"), arg),
                              c(
                                a(str("inner"), arg),
                                a(str("inner-range"), arg),
                                a(str("inner-list"), arg)
                              )
                          )
                      ).as(:oneline)
                    ),
                    a(str("native-inner-vlan-id"), arg),
                    str("inner-vlan-id-range").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"),
                        c(
                            c(
                              str("cell"),
                              str("aal5")
                            )
                        )
                    ).as(:oneline),
                    b(str("vci-range"),
                        c(
                            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"),
                        c(
                            c(
                              a(str("oam-period"), arg),
                              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("demux-options"),
                      demux_options_type
                    ),
                    str("targetted-distribution"),
                    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),
                    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),
                                    a(str("queues"), arg),
                                    b(str("port"),
                                        c(
                                            a(str("minimum"), arg),
                                            a(str("maximum"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("maximum-contexts"),
                                        c(
                                            a(str("number"), 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("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
                    ),
                    str("atm-policer"),
                    str("layer2-policer"),
                    str("filter"),
                    b(str("multi-chassis-protection"),
                      multi_chassis_protection_group
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("targeted-broadcast"),
                                        c(
                                            c(
                                              str("forward-and-send-to-re"),
                                              str("forward-only")
                                            )
                                        )
                                    ),
                                    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")
                                        )
                                    ),
                                    a(str("mac-validate"), arg),
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                c(
                                                    str("loose")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    a(str("mtu"), arg),
                                    str("no-redirects"),
                                    str("no-neighbor-learn"),
                                    str("unconditional-src-learn"),
                                    str("multicast-only"),
                                    str("primary"),
                                    a(str("ipsec-sa"), arg),
                                    str("demux-source"),
                                    str("demux-destination"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  ca(
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  ca(
                                                      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),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg),
                                            a(str("dialer"), arg)
                                        )
                                    ),
                                    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(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"),
                                                        c(
                                                            c(
                                                              a(str("oam_period"), arg),
                                                              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),
                                                c(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicaset
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(str("web-authentication"),
                                                c(
                                                    str("http"),
                                                    str("https"),
                                                    str("redirect-to-https")
                                                )
                                            ),
                                            b(str("vrrp-group"),
                                              vrrp_group
                                            )
                                        )
                                    ),
                                    b(str("unnumbered-address"),
                                        c(
                                            b(str("source"),
                                              interface_unit
                                            ),
                                            a(str("preferred-source-address"), arg),
                                            b(str("destination"),
                                              ipv4addr
                                            ),
                                            a(str("destination-profile"), arg)
                                        )
                                    ).as(:oneline),
                                    str("location-pool-address"),
                                    str("negotiate-address"),
                                    b(str("dhcp"),
                                        c(
                                            b(str("client-identifier"),
                                                c(
                                                    c(
                                                      a(str("ascii"), arg),
                                                      a(str("hexadecimal"), arg)
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("lease-time"), arg),
                                            a(str("retransmission-attempt"), arg),
                                            a(str("retransmission-interval"), arg),
                                            b(str("server-address"),
                                              ipv4addr
                                            ),
                                            str("update-server"),
                                            a(str("vendor-id"), arg)
                                        )
                                    ),
                                    b(str("dhcp-client"),
                                      dhcp_client_type
                                    )
                                )
                            ),
                            b(str("iso"),
                                c(
                                    a(str("address"), arg),
                                    a(str("mtu"), arg)
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                c(
                                                    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("nd6-stale-time"), arg),
                                    str("no-neighbor-learn"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  ca(
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  ca(
                                                      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),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg),
                                            a(str("dialer"), arg)
                                        )
                                    ),
                                    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(a(str("address"), arg),
                                        c(
                                            b(str("destination"),
                                              ipv6addr
                                            ),
                                            str("eui-64"),
                                            str("primary"),
                                            str("preferred"),
                                            str("master-only"),
                                            b(a(str("ndp"), arg),
                                                c(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicaset
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(str("vrrp-inet6-group"),
                                              vrrp_group
                                            ),
                                            b(str("web-authentication"),
                                                c(
                                                    str("http"),
                                                    str("https"),
                                                    str("redirect-to-https")
                                                )
                                            )
                                        )
                                    ),
                                    str("demux-source"),
                                    str("demux-destination"),
                                    b(str("unnumbered-address"),
                                        c(
                                            b(str("source"),
                                              interface_unit
                                            ),
                                            a(str("preferred-source-address"), arg)
                                        )
                                    ).as(:oneline),
                                    str("dad-disable"),
                                    str("no-dad-disable"),
                                    b(str("dhcpv6-client"),
                                        c(
                                            a(str("client-type"), arg),
                                            a(str("client-ia-type"), str("ia-na") | str("ia-pd")),
                                            str("rapid-commit"),
                                            b(str("update-router-advertisement"),
                                                c(
                                                    a(str("interface"), arg)
                                                )
                                            ),
                                            b(str("client-identifier"),
                                                c(
                                                    a(str("duid-type"), arg)
                                                )
                                            ).as(:oneline),
                                            a(str("req-option"), 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("update-server"),
                                            a(str("retransmission-attempt"), 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)
                                            ),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("group"), arg),
                                            a(str("dialer"), arg)
                                        )
                                    ),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("mlppp"),
                                c(
                                    b(str("bundle"),
                                      interface_unit
                                    )
                                )
                            ),
                            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(
                                    b(str("filter"),
                                        c(
                                            c(
                                              a(str("input"), arg),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    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
                                            )
                                        )
                                    ),
                                    str("protocols")
                                )
                            ),
                            b(str("vpls"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  ca(
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  ca(
                                                      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),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  ca(
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  ca(
                                                      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),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    a(str("interface-mode"), arg),
                                    a(str("bridge-domain-type"), arg),
                                    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),
                                                c(
                                                    a(str("to-vlan-id"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    c(
                                      a(str("isid-list"), arg)
                                    ),
                                    b(str("storm-control"),
                                      storm_control
                                    )
                                )
                            ),
                            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)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("service-domain"), arg),
                    str("copy-tos-to-outer-ip-header"),
                    b(str("dialer-options"),
                        c(
                            a(str("pool"), arg),
                            a(str("dial-string"), arg),
                            b(str("incoming-map"),
                                c(
                                    c(
                                      a(str("caller"), arg).as(:oneline),
                                      str("accept-all")
                                    )
                                )
                            ),
                            str("callback"),
                            a(str("callback-wait-period"), arg),
                            a(str("redial-delay"), arg),
                            a(str("idle-timeout"), arg),
                            a(str("watch-list"), arg),
                            a(str("load-threshold"), arg),
                            a(str("load-interval"), arg),
                            a(str("activation-delay"), arg),
                            a(str("deactivation-delay"), arg),
                            a(str("initial-route-check"), arg)
                        )
                    ),
                    b(str("backup-options"),
                        c(
                            b(str("interface"),
                              interface_name
                            )
                        )
                    ),
                    str("dynamic-call-admission-control")
                )
            ),
            b(str("no-partition"),
                c(
                    a(str("interface-type"), arg)
                )
            ).as(:oneline),
            b(a(str("partition"), arg),
                c(
                    a(str("oc-slice"), arg),
                    a(str("timeslots"), arg),
                    a(str("interface-type"), arg)
                )
            ).as(:oneline),
            b(str("modem-options"),
                c(
                    a(str("init-command-string"), arg),
                    a(str("dialin"), arg)
                )
            ),
            b(str("isdn-options"),
                c(
                    a(str("switch-type"), arg),
                    a(str("media-type"), arg),
                    a(str("spid1"), arg),
                    a(str("spid2"), arg),
                    a(str("calling-number"), arg),
                    b(a(str("incoming-called-number"), arg),
                        c(
                            str("reject")
                        )
                    ).as(:oneline),
                    a(str("tei-option"), arg),
                    a(str("static-tei-val"), arg),
                    a(str("t310"), arg),
                    a(str("bchannel-allocation"), arg)
                )
            ),
            b(str("dialer-options"),
                c(
                    b(a(str("pool"), arg),
                        c(
                            a(str("priority"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("redundant-pseudo-interface-options"),
                c(
                    a(str("redundancy-group"), arg)
                )
            ),
            str("cellular-options")
        )
      )
    end

    rule(:ip_monitoring_address_type) do
      b(arg.as(:arg),
        c(
            a(str("weight"), arg),
            b(str("interface"),
                s(
                  a(str("logical-interface-name"), arg),
                  a(str("secondary-ip-address"), arg)
                )
            )
        )
      )
    end

    rule(:jsrc_partition_definition) do
        c(
            str("partition")
        )
    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
            ),
            b(str("address-pool"),
              address_pool_object
            ),
            b(str("group-profile"),
              group_profile_object
            ),
            b(a(str("profile"), arg),
                c(
                    a(str("accounting-order"), arg),
                    a(str("authentication-order"), arg),
                    str("authorization-order"),
                    a(str("provisioning-order"), arg),
                    b(str("client"),
                      access_client_object
                    ),
                    b(str("address-assignment"),
                        c(
                            a(str("pool"), arg)
                        )
                    ),
                    b(str("radius"),
                        c(
                            b(str("authentication-server"),
                              ipv4addr
                            ),
                            b(str("accounting-server"),
                              ipv4addr
                            ),
                            str("options"),
                            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")
                                        )
                                    ),
                                    b(str("exclude"),
                                        c(
                                            a(str("accounting-authentic"), arg),
                                            a(str("accounting-delay-time"), arg),
                                            a(str("accounting-session-id"), arg),
                                            a(str("accounting-terminate-cause"), arg),
                                            a(str("called-station-id"), arg),
                                            a(str("calling-station-id"), arg),
                                            a(str("class"), arg),
                                            a(str("delegated-ipv6-prefix"), arg),
                                            a(str("dhcp-options"), arg),
                                            a(str("dhcp-gi-address"), arg),
                                            a(str("dhcp-mac-address"), arg),
                                            a(str("output-filter"), arg),
                                            a(str("event-time-stamp"), arg),
                                            a(str("framed-ip-address"), arg),
                                            a(str("framed-ip-netmask"), arg),
                                            a(str("framed-ip-route"), arg),
                                            a(str("framed-ipv6-pool"), arg),
                                            a(str("framed-ipv6-prefix"), arg),
                                            a(str("framed-ipv6-route"), arg),
                                            a(str("framed-pool"), arg),
                                            a(str("input-filter"), arg),
                                            a(str("input-gigapackets"), arg),
                                            a(str("input-gigawords"), arg),
                                            a(str("input-ipv6-packets"), arg),
                                            a(str("input-ipv6-gigawords"), arg),
                                            a(str("input-ipv6-octets"), arg),
                                            a(str("interface-description"), arg),
                                            a(str("nas-identifier"), arg),
                                            a(str("nas-port"), arg),
                                            a(str("nas-port-id"), arg),
                                            a(str("nas-port-type"), arg),
                                            a(str("output-gigapackets"), arg),
                                            a(str("output-gigawords"), arg),
                                            a(str("output-ipv6-packets"), arg),
                                            a(str("output-ipv6-gigawords"), arg),
                                            a(str("output-ipv6-octets"), arg),
                                            a(str("dynamic-iflset-name"), arg),
                                            a(str("dsl-forum-attributes"), arg),
                                            a(str("l2c-upstream-data"), arg),
                                            a(str("l2c-downstream-data"), arg),
                                            a(str("acc-loop-cir-id"), arg),
                                            a(str("acc-aggr-cir-id-bin"), arg),
                                            a(str("acc-aggr-cir-id-asc"), arg),
                                            a(str("act-data-rate-up"), arg),
                                            a(str("act-data-rate-dn"), arg),
                                            a(str("min-data-rate-up"), arg),
                                            a(str("min-data-rate-dn"), arg),
                                            a(str("att-data-rate-up"), arg),
                                            a(str("att-data-rate-dn"), arg),
                                            a(str("max-data-rate-up"), arg),
                                            a(str("max-data-rate-dn"), arg),
                                            a(str("min-lp-data-rate-up"), arg),
                                            a(str("min-lp-data-rate-dn"), arg),
                                            a(str("max-interlv-delay-up"), arg),
                                            a(str("act-interlv-delay-up"), arg),
                                            a(str("max-interlv-delay-dn"), arg),
                                            a(str("act-interlv-delay-dn"), arg),
                                            a(str("dsl-line-state"), arg),
                                            a(str("dsl-type"), arg),
                                            a(str("downstream-calculated-qos-rate"), arg),
                                            a(str("upstream-calculated-qos-rate"), arg),
                                            a(str("framed-interface-id"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("session-options"),
                        c(
                            a(str("client-group"), arg),
                            a(str("client-idle-timeout"), arg),
                            a(str("client-session-timeout"), 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(
                            a(str("order"), arg),
                            str("accounting-stop-on-failure"),
                            str("accounting-stop-on-access-deny"),
                            str("immediate-update"),
                            str("coa-immediate-update"),
                            a(str("update-interval"), arg),
                            a(str("statistics"), arg),
                            str("duplication")
                        )
                    ),
                    str("service")
                )
            ),
            b(str("address-assignment"),
              address_assignment_type
            ),
            str("address-protection"),
            str("tunnel-profile"),
            b(str("domain"),
              domain_map_type
            ),
            b(str("ppp-options"),
                c(
                    b(str("compliance"),
                        c(
                            a(str("rfc"), arg)
                        )
                    )
                )
            ),
            b(str("gx-plus"),
              gx_plus_definition
            ),
            b(str("terminate-code"),
                c(
                    b(str("aaa"),
                        c(
                            b(str("deny"),
                                c(
                                    b(str("authentication-denied"),
                                        c(
                                            b(str("radius"),
                                                c(
                                                    a(str("acct-terminate-cause"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("no-resources"),
                                        c(
                                            b(str("radius"),
                                                c(
                                                    a(str("acct-terminate-cause"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("server-request-timeout"),
                                        c(
                                            b(str("radius"),
                                                c(
                                                    a(str("acct-terminate-cause"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("shutdown"),
                                c(
                                    b(str("administrative-reset"),
                                        c(
                                            b(str("radius"),
                                                c(
                                                    a(str("acct-terminate-cause"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("remote-reset"),
                                        c(
                                            b(str("radius"),
                                                c(
                                                    a(str("acct-terminate-cause"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("dhcp"),
                        c(
                            b(str("client-request"),
                                c(
                                    b(str("radius"),
                                        c(
                                            a(str("acct-terminate-cause"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("lost-carrier"),
                                c(
                                    b(str("radius"),
                                        c(
                                            a(str("acct-terminate-cause"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("nak"),
                                c(
                                    b(str("radius"),
                                        c(
                                            a(str("acct-terminate-cause"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("nas-logout"),
                                c(
                                    b(str("radius"),
                                        c(
                                            a(str("acct-terminate-cause"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("no-offers"),
                                c(
                                    b(str("radius"),
                                        c(
                                            a(str("acct-terminate-cause"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    str("l2tp"),
                    str("ppp")
                )
            ),
            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("firewall-authentication"),
                c(
                    b(str("pass-through"),
                        c(
                            a(str("default-profile"), arg),
                            b(str("ftp"),
                              banner_object
                            ),
                            b(str("telnet"),
                              banner_object
                            ),
                            b(str("http"),
                              banner_object
                            )
                        )
                    ),
                    b(str("web-authentication"),
                        c(
                            a(str("default-profile"), arg),
                            b(str("banner"),
                                c(
                                    a(str("success"), arg)
                                )
                            )
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sca(
                                    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"), str("configuration") | str("setup") | str("authentication") | str("all")).as(:oneline)
                        )
                    )
                )
            )
        )
    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(
              str("ppp"),
              str("l2tp")
            ),
            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("request-rate"), arg)
        )
    end

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

    rule(:address_assignment_type) do
        c(
            b(str("neighbor-discovery-router-advertisement"),
                c(
                    a(str("ndra-name"), 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("pool"), arg),
                c(
                    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
                                              )
                                          )
                                      )
                                  )
                              ),
                              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
                                      )
                                  )
                              )
                            )
                        )
                    )
                )
            ),
            str("location-pool")
        )
    end

    rule(:address_pool_object) do
      b(arg.as(:arg),
        c(
            c(
              b(str("address"),
                ipv4prefix
              ),
              b(str("address-range"),
                  c(
                      b(str("low"),
                        ipv4addr
                      ),
                      b(str("high"),
                        ipv4addr
                      ),
                      b(str("mask"),
                        ipv4addr
                      )
                  )
              ).as(:oneline)
            ),
            b(str("primary-dns"),
              hostname
            ),
            b(str("secondary-dns"),
              hostname
            ),
            b(str("primary-wins"),
              hostname
            ),
            b(str("secondary-wins"),
              hostname
            )
        )
      )
    end

    rule(:banner_object) do
        c(
            b(str("banner"),
                c(
                    a(str("login"), arg),
                    a(str("success"), arg),
                    a(str("fail"), arg)
                )
            )
        )
    end

    rule(:dhcp_attribute_type) do
        c(
            b(str("option-match"),
                c(
                    b(str("option-82"),
                        c(
                            b(a(str("circuit-id"), arg),
                                c(
                                    a(str("range"), arg)
                                )
                            ).as(:oneline),
                            b(a(str("remote-id"), arg),
                                c(
                                    a(str("range"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            a(str("maximum-lease-time"), 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
            ),
            a(str("netbios-node-type"), arg),
            b(str("sip-server"),
                c(
                    a(str("name"), arg),
                    a(str("ip-address"), arg)
                )
            ),
            a(str("sip-server-domain-name"), arg),
            a(str("sip-server-address"), arg),
            a(str("dns-server"), arg),
            b(str("propagate-settings"),
              interface_name
            ),
            b(str("propagate-ppp-settings"),
              interface_name
            ),
            b(a(str("option"), arg),
                c(
                    c(
                      a(str("flag"), arg),
                      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(
                                a(str("flag"), arg),
                                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)
        )
    end

    rule(:domain_map_type) do
        c(
            b(a(str("map"), arg),
                c(
                    c(
                      a(str("aaa-routing-instance"), arg),
                      b(a(str("aaa-logical-system"), arg),
                          c(
                              a(str("aaa-routing-instance"), arg)
                          )
                      )
                    ),
                    a(str("access-profile"), arg),
                    a(str("address-pool"), arg),
                    a(str("dynamic-profile"), arg),
                    b(a(str("padn"), arg),
                        c(
                            b(str("mask"),
                              ipv4addr
                            ),
                            a(str("metric"), arg)
                        )
                    ),
                    c(
                      a(str("target-routing-instance"), arg),
                      b(a(str("target-logical-system"), arg),
                          c(
                              a(str("target-routing-instance"), arg)
                          )
                      )
                    ),
                    str("strip-domain"),
                    a(str("tunnel-profile"), arg)
                )
            ),
            b(str("delimiter"),
                c(
                    a(str("characters"), arg)
                )
            ).as(:oneline),
            b(str("parse-direction"),
                c(
                    c(
                      str("left-to-right"),
                      str("right-to-left")
                    )
                )
            ).as(:oneline)
        )
    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("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)
                )
            ),
            str("l2tp")
        )
      )
    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(
                    a(str("max-outstanding-requests"), arg)
                )
            )
        )
    end

    rule(:juniper_bridge_domains) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("domain-type"), arg),
            c(
              a(str("vlan-id"), arg),
              b(str("vlan-tags"),
                  c(
                      a(str("outer"), arg),
                      a(str("inner"), arg)
                  )
              ).as(:oneline),
              a(str("vlan-id-list"), arg)
            ),
            a(str("service-id"), arg),
            str("no-local-switching"),
            str("no-irb-layer-2-copy"),
            a(str("interface"), arg | str("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_protocols_igmp_snooping
                    )
                )
            )
        )
      )
    end

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

    rule(:jdhcp_relay_type) do
        c(
            str("duplicate-clients-on-interface"),
            b(str("dhcpv6"),
              dhcpv6_relay_type
            ),
            str("forward-snooped-clients").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),
            b(str("overrides"),
              override_type
            ),
            b(str("relay-option-60"),
              relay_option_60_type_top
            ),
            b(str("relay-option-82"),
              relay_option_82_type
            ),
            b(str("server-group"),
              server_group_type
            ),
            a(str("active-server-group"), arg),
            b(str("group"),
              dhcp_group
            )
        )
    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"),
                        c(
                            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")
                )
            )
        )
    end

    rule(:dhcp_group) do
      b(arg.as(:arg),
        c(
            a(str("active-server-group"), arg),
            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),
            b(str("overrides"),
              override_type
            ),
            b(str("relay-option-60"),
              relay_option_60_type_group
            ),
            b(str("relay-option-82"),
              relay_option_82_type
            ),
            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)
                )
            )
        )
      )
    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
                      )
                    )
                )
            )
        )
    end

    rule(:dhcp_bfd_liveness_detection_type) do
        c(
            a(str("version"), arg),
            a(str("minimum-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("session-mode"), arg),
            a(str("holddown-interval"), 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(:dhcpv6_relay_type) do
        c(
            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),
            b(str("overrides"),
              dhcpv6_override_relay_type
            ),
            b(str("group"),
              dhcpv6_relay_group
            ),
            b(str("relay-agent-interface-id"),
              v6_relay_option_interface_id_type
            ),
            b(str("server-group"),
              v6_server_group_type
            ),
            a(str("active-server-group"), arg)
        )
    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("client-id"),
                    str("relay-agent-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")
                )
            )
        )
    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
                      )
                    )
                )
            )
        )
    end

    rule(:dhcpv6_override_relay_type) do
        c(
            str("allow-snooped-clients"),
            str("no-allow-snooped-clients"),
            a(str("interface-client-limit"), arg),
            str("no-bind-on-request"),
            str("send-release-on-delete")
        )
    end

    rule(:dhcpv6_relay_group) do
      b(arg.as(:arg),
        c(
            a(str("active-server-group"), arg),
            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),
            b(str("overrides"),
              dhcpv6_override_relay_type
            ),
            b(str("relay-agent-interface-id"),
              v6_relay_option_interface_id_type
            ),
            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)
                )
            )
        )
      )
    end

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

    rule(:juniper_class_of_service_options) do
        c(
            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("discard")
                                )
                            )
                        )
                    ),
                    b(a(str("class"), arg),
                        c(
                            b(str("classification-override"),
                                c(
                                    a(str("forwarding-class"), arg)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("classifiers"),
                c(
                    b(a(str("dscp"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("dscp-ipv6"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("exp"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("ieee-802.1"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("inet-precedence"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("ieee-802.1ad"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-points"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            str("forwarding-class-map"),
            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"),
                                c(
                                    a(str("code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            str("loss-priority-rewrites"),
            b(str("code-point-aliases"),
                c(
                    b(a(str("dscp"), arg),
                        c(
                            a(str("bits"), arg)
                        )
                    ).as(:oneline),
                    b(a(str("dscp-ipv6"), arg),
                        c(
                            a(str("bits"), arg)
                        )
                    ).as(:oneline),
                    b(a(str("exp"), arg),
                        c(
                            a(str("bits"), arg)
                        )
                    ).as(:oneline),
                    b(a(str("ieee-802.1"), arg),
                        c(
                            a(str("bits"), arg)
                        )
                    ).as(:oneline),
                    b(a(str("inet-precedence"), arg),
                        c(
                            a(str("bits"), arg)
                        )
                    ).as(:oneline),
                    b(a(str("ieee-802.1ad"), arg),
                        c(
                            a(str("bits"), 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),
                                c(
                                    a(str("from-code-points"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    str("to-inet-precedence-from-inet-precedence"),
                    str("to-dscp-from-dscp"),
                    str("to-dscp-ipv6-from-dscp-ipv6"),
                    str("to-exp-from-exp")
                )
            ),
            b(str("host-outbound-traffic"),
                c(
                    a(str("forwarding-class"), arg),
                    a(str("dscp-code-point"), arg),
                    b(str("translation-table"),
                        c(
                            a(str("to-802.1p-from-dscp"), arg)
                        )
                    ).as(:oneline),
                    b(str("tcp"),
                        c(
                            str("raise-internet-control-priority")
                        )
                    ),
                    str("ieee-802.1")
                )
            ),
            b(a(str("drop-profiles"), arg),
                c(
                    b(a(str("fill-level"), arg),
                        c(
                            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"), str("becn"),
                        c(
                            b(str("shaping-rate"),
                                c(
                                    c(
                                      a(str("absolute-rate"), arg),
                                      a(str("percent"), arg)
                                    )
                                )
                            ).as(:oneline)
                        )
                    ).as(:oneline)
                )
            ),
            a(str("virtual-channels"), arg),
            b(a(str("virtual-channel-groups"), arg),
                c(
                    b(a(str("channel"), arg),
                        c(
                            a(str("scheduler-map"), arg),
                            b(str("shaping-rate"),
                                c(
                                    c(
                                      a(str("absolute-rate"), arg),
                                      a(str("percent"), arg)
                                    )
                                )
                            ).as(:oneline),
                            str("default")
                        )
                    )
                )
            ),
            str("copy-plp-all"),
            str("tri-color"),
            b(str("shared-buffer"),
                c(
                    b(str("egress"),
                        c(
                            a(str("buffer-partition"), str("lossless") | str("lossy") | str("multicast"),
                                a(str("percent"), arg)
                            ),
                            a(str("percent"), arg)
                        )
                    ),
                    b(str("ingress"),
                        c(
                            a(str("buffer-partition"), str("lossless-headroom") | str("lossless") | str("lossy"),
                                a(str("percent"), arg)
                            ),
                            a(str("percent"), arg)
                        )
                    )
                )
            ),
            b(str("forwarding-classes"),
                c(
                    str("class").as(:oneline),
                    b(a(str("queue"), arg),
                        ca(
                            a(str("priority"), arg),
                            a(str("policing-priority"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            str("restricted-queues"),
            b(a(str("traffic-control-profiles"), arg),
                c(
                    a(str("scheduler-map"), arg),
                    a(str("atm-service"), arg),
                    a(str("peak-rate"), arg),
                    a(str("sustained-rate"), arg),
                    a(str("max-burst-size"), arg),
                    b(str("shaping-rate"),
                        c(
                            c(
                              a(str("rate"), arg),
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("overhead-accounting"),
                        c(
                            a(str("mode"), arg),
                            a(str("bytes"), arg)
                        )
                    ).as(:oneline),
                    str("shaping-rate-priority-high").as(:oneline),
                    str("shaping-rate-priority-medium").as(:oneline),
                    str("shaping-rate-priority-low").as(:oneline),
                    str("shaping-rate-excess-high").as(:oneline),
                    str("shaping-rate-excess-low").as(:oneline),
                    b(str("guaranteed-rate"),
                        c(
                            c(
                              a(str("rate"), arg),
                              a(str("percent"), arg)
                            ),
                            a(str("burst-size"), arg)
                        )
                    ).as(:oneline),
                    str("excess-rate").as(:oneline),
                    str("excess-rate-high").as(:oneline),
                    str("excess-rate-low").as(:oneline),
                    c(
                      b(str("delay-buffer-rate"),
                          c(
                              c(
                                a(str("rate"), arg),
                                a(str("percent"), arg),
                                a(str("cps"), arg)
                              )
                          )
                      ).as(:oneline)
                    ),
                    str("adjust-minimum").as(:oneline)
                )
            ),
            str("forwarding-class-sets"),
            str("congestion-notification-profile"),
            str("dynamic-class-of-service-options"),
            b(str("interfaces"),
                c(
                    str("interface-set"),
                    cos_interfaces_type
                )
            ),
            b(a(str("routing-instances"), arg),
                c(
                    b(str("classifiers"),
                        c(
                            b(str("exp"),
                                c(
                                    arg
                                )
                            ).as(:oneline),
                            str("ieee-802.1").as(:oneline),
                            b(str("dscp"),
                                c(
                                    arg
                                )
                            ).as(:oneline),
                            b(str("dscp-ipv6"),
                                c(
                                    arg
                                )
                            ).as(:oneline)
                        )
                    ),
                    str("rewrite-rules")
                )
            ),
            b(str("rewrite-rules"),
                c(
                    b(a(str("dscp"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("dscp-ipv6"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("exp"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("ieee-802.1"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("inet-precedence"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("frame-relay-de"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(a(str("ieee-802.1ad"), arg),
                        c(
                            a(str("import"), arg),
                            b(a(str("forwarding-class"), arg),
                                c(
                                    a(str("loss-priority"), str("low") | str("high") | str("medium-low") | str("medium-high"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            str("fabric"),
            b(a(str("scheduler-maps"), arg),
                c(
                    b(a(str("forwarding-class"), arg),
                        c(
                            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(
                            c(
                              a(str("rate"), arg),
                              a(str("percent"), arg),
                              b(str("remainder"),
                                  c(
                                      a(str("percent"), arg)
                                  )
                              )
                            ),
                            c(
                              str("exact"),
                              str("rate-limit")
                            )
                        )
                    ),
                    str("excess-rate").as(:oneline),
                    b(str("shaping-rate"),
                        c(
                            c(
                              a(str("rate"), arg),
                              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(
                                      a(str("percent"), arg)
                                  )
                              ),
                              a(str("temporal"), arg)
                            ),
                            c(
                              str("exact")
                            )
                        )
                    ),
                    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("drop-profile-map-set"),
                    a(str("adjust-percent"), arg),
                    a(str("adjust-minimum"), arg)
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sca(
                            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"), 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("all")).as(:oneline)
                )
            ),
            str("multi-destination"),
            str("application-traffic-control")
        )
    end

    rule(:cos_interfaces_type) do
      b(arg.as(:arg),
        c(
            str("forwarding-class-set"),
            a(str("congestion-notification-profile"), arg),
            a(str("scheduler-map"), arg),
            a(str("input-scheduler-map"), arg),
            a(str("scheduler-map-chassis"), arg),
            a(str("output-forwarding-class-map"), arg),
            b(str("shaping-rate"),
                c(
                    a(str("rate"), arg)
                )
            ).as(:oneline),
            str("input-excess-bandwidth-share").as(:oneline),
            str("excess-bandwidth-share").as(:oneline),
            b(str("input-shaping-rate"),
                c(
                    a(str("rate"), arg)
                )
            ).as(:oneline),
            b(str("input-traffic-control-profile"),
                c(
                    a(str("profile-name"), arg)
                )
            ).as(:oneline),
            b(str("input-traffic-control-profile-remaining"),
                c(
                    a(str("profile-name"), arg)
                )
            ).as(:oneline),
            str("output-traffic-control-profile").as(:oneline),
            str("output-traffic-control-profile-remaining").as(:oneline),
            b(str("member-link-scheduler"),
                c(
                    c(
                      str("scale"),
                      str("replicate")
                    )
                )
            ).as(:oneline),
            a(str("unit"), 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"),
                        c(
                            c(
                              a(str("rate"), arg),
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("input-shaping-rate"),
                        c(
                            c(
                              a(str("rate"), arg),
                              a(str("percent"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("input-traffic-control-profile"),
                        c(
                            a(str("profile-name"), arg),
                            a(str("shared-instance"), arg)
                        )
                    ).as(:oneline),
                    b(str("output-traffic-control-profile"),
                        c(
                            a(str("profile-name"), arg),
                            a(str("shared-instance"), arg)
                        )
                    ).as(:oneline),
                    b(str("classifiers"),
                        c(
                            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(
                                    arg
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1"),
                                ca(
                                    a(str("vlan-tag"), arg)
                                )
                            ).as(:oneline),
                            b(str("inet-precedence"),
                                c(
                                    arg
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1ad"),
                                ca(
                                    a(str("vlan-tag"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("loss-priority-maps"),
                        c(
                            b(str("frame-relay-de"),
                                c(
                                    a(str("lpmap-name"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("rewrite-rules"),
                        c(
                            a(str("dscp"), str("default"),
                                c(
                                    a(str("protocol"), arg)
                                )
                            ).as(:oneline),
                            a(str("dscp-ipv6"), str("default"),
                                c(
                                    a(str("protocol"), arg)
                                )
                            ).as(:oneline),
                            a(str("exp"), str("default"),
                                c(
                                    a(str("protocol"), arg)
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1"),
                                c(
                                    a(str("rewrite-rule-name"), arg),
                                    a(str("vlan-tag"), arg)
                                )
                            ).as(:oneline),
                            a(str("inet-precedence"), str("default"),
                                c(
                                    a(str("protocol"), arg)
                                )
                            ).as(:oneline),
                            str("exp-swap-push-push").as(:oneline),
                            str("exp-push-push-push").as(:oneline),
                            b(str("frame-relay-de"),
                                c(
                                    a(str("rewrite-rule-name"), arg)
                                )
                            ).as(:oneline),
                            b(str("ieee-802.1ad"),
                                c(
                                    a(str("rewrite-rule-name"), arg),
                                    a(str("vlan-tag"), arg)
                                )
                            )
                        )
                    ),
                    str("loss-priority-rewrites"),
                    str("translation-table")
                )
            )
        )
      )
    end

    rule(:juniper_def_rtb_switch_options) do
        c(
            b(str("mac-table-size"),
                c(
                    a(str("limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            b(str("interface-mac-limit"),
                c(
                    a(str("limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("mac-statistics"),
            a(str("service-id"), arg),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        c(
                            a(str("limit"), arg),
                            a(str("packet-action"), arg)
                        )
                    ),
                    str("no-mac-learning")
                )
            )
        )
    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("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)
                        )
                    ),
                    b(str("other-variables"),
                      base_default_variable_object
                    )
                )
            ),
            b(str("routing-instances"),
                c(
                    a(str("instance"), arg,
                        c(
                            a(str("interface"), arg | str("interface-name"),
                                c(
                                    c(
                                      str("any"),
                                      str("unicast"),
                                      str("multicast")
                                    )
                                )
                            ),
                            b(str("routing-options"),
                                c(
                                    b(a(str("rib"), arg),
                                        c(
                                            b(str("static"),
                                                c(
                                                    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"),
                                                            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"),
                                                              ca(
                                                                    a(str("origin"), arg),
                                                                    str("atomic-aggregate"),
                                                                    b(str("aggregator"),
                                                                        ca(
                                                                            b(str("address"),
                                                                              ipv4addr
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    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
                                                            ),
                                                            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
                                                            ),
                                                            a(str("backup-pe-group"), arg),
                                                            b(str("bfd-liveness-detection"),
                                                                c(
                                                                    a(str("version"), arg),
                                                                    a(str("minimum-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),
                                                                            a(str("algorithm"), arg),
                                                                            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"),
                                                            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"),
                                                              ca(
                                                                    a(str("origin"), arg),
                                                                    str("atomic-aggregate"),
                                                                    b(str("aggregator"),
                                                                        ca(
                                                                            b(str("address"),
                                                                              ipv4addr
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    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
                                                            ),
                                                            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
                                                            ),
                                                            a(str("backup-pe-group"), arg),
                                                            b(str("bfd-liveness-detection"),
                                                                c(
                                                                    a(str("version"), arg),
                                                                    a(str("minimum-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),
                                                                            a(str("algorithm"), arg),
                                                                            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"),
                                                            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"),
                                                              ca(
                                                                    a(str("origin"), arg),
                                                                    str("atomic-aggregate"),
                                                                    b(str("aggregator"),
                                                                        ca(
                                                                            b(str("address"),
                                                                              ipv4addr
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("martians"),
                                              martian_type
                                            ),
                                            b(str("aggregate"),
                                              rib_aggregate_type
                                            ),
                                            b(str("generate"),
                                              rib_aggregate_type
                                            ),
                                            c(
                                              b(str("maximum-paths"),
                                                  c(
                                                      a(str("limit"), arg),
                                                      c(
                                                        a(str("threshold"), arg),
                                                        str("log-only")
                                                      ),
                                                      a(str("log-interval"), arg)
                                                  )
                                              ).as(:oneline)
                                            ),
                                            b(str("maximum-prefixes"),
                                                c(
                                                    a(str("limit"), 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"),
                                                        c(
                                                            str("equal-external-internal")
                                                        )
                                                    ).as(:oneline),
                                                    str("as-path-compare")
                                                )
                                            ),
                                            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)
                                                        )
                                                    )
                                                )
                                            ),
                                            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("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)
                                                )
                                            )
                                        )
                                    ),
                                    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"),
                                                      trace_file_type
                                                    ),
                                                    a(str("flag"), str("parse") | str("config-internal") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                                        c(
                                                            str("disable")
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            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"),
                                                        c(
                                                            a(str("bandwidth-value"), arg),
                                                            str("adaptive")
                                                        )
                                                    ).as(:oneline),
                                                    b(str("redundant-sources"),
                                                      ipaddr
                                                    ),
                                                    b(str("forwarding-cache"),
                                                        c(
                                                            b(str("timeout"),
                                                                c(
                                                                    c(
                                                                      a(str("timeout-value"), arg),
                                                                      b(str("never"),
                                                                          c(
                                                                              str("non-discard-entry-only")
                                                                          )
                                                                      )
                                                                    )
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            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(
                                                    b(str("threshold"),
                                                        c(
                                                            a(str("suppress"), arg),
                                                            a(str("reuse"), 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(a(str("backup-pe-group"), arg),
                                                c(
                                                    b(str("backups"),
                                                      ipaddr
                                                    ),
                                                    b(str("local-address"),
                                                      ipaddr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("interfaces"),
                c(
                    str("pic-set"),
                    a(str("interface-set"), arg | str("interface-set-name"),
                        c(
                            b(a(str("interface"), arg),
                                c(
                                    a(str("unit"), arg),
                                    a(str("vlan-tags-outer"), arg)
                                )
                            )
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sca(
                                    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"), str("all") | str("kernel") | str("change-events") | str("kernel-detail") | str("config-states") | str("resource-usage") | str("gres-events") | str("select-events"),
                                c(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("interface-range"), arg),
                        c(
                            a(str("member"), arg),
                            b(a(str("member-range"), arg),
                                c(
                                    b(str("end-range"),
                                      interface_device
                                    )
                                )
                            ).as(:oneline),
                            a(str("description"), quote | arg),
                            a(str("metadata"), arg),
                            c(
                              str("disable")
                            ),
                            str("promiscuous-mode"),
                            a(str("port-mirror-instance"), arg),
                            str("multicast-statistics"),
                            b(str("fabric-options"),
                                c(
                                    a(str("member-interfaces"), arg)
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    a(str("flag"), str("ipc") | str("event") | str("media") | str("all") | str("q921") | str("q931")).as(:oneline),
                                    b(str("file"),
                                        sca(
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable")
                                        )
                                    )
                                )
                            ),
                            str("passive-monitor-mode"),
                            c(
                              b(str("keepalives"),
                                keepalives_type
                              ).as(:oneline),
                              str("no-keepalives")
                            ),
                            str("traps"),
                            str("no-traps"),
                            a(str("accounting-profile"), arg),
                            c(
                              str("per-unit-scheduler"),
                              str("no-per-unit-scheduler"),
                              str("shared-scheduler"),
                              b(str("hierarchical-scheduler"),
                                  c(
                                      a(str("maximum-hierarchy-levels"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            a(str("schedulers"), arg),
                            str("interface-transmit-statistics"),
                            str("dce"),
                            c(
                              str("vlan-tagging"),
                              str("stacked-vlan-tagging"),
                              str("flexible-vlan-tagging"),
                              str("vlan-vci-tagging")
                            ),
                            a(str("native-vlan-id"), arg),
                            a(str("speed"), 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("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)
                                )
                            ),
                            str("ima-group-options"),
                            str("ima-link-options"),
                            b(str("multi-chassis-protection"),
                              multi_chassis_protection_group
                            ),
                            b(str("clocking"),
                                c(
                                    c(
                                      str("internal"),
                                      b(str("external"),
                                          c(
                                              b(str("interface"),
                                                interface_device
                                              )
                                          )
                                      )
                                    )
                                )
                            ).as(:oneline),
                            a(str("link-mode"), arg),
                            a(str("media-type"), arg),
                            a(str("encapsulation"), arg),
                            b(str("framing"),
                                c(
                                    c(
                                      str("lan-phy"),
                                      str("wan-phy"),
                                      str("sonet"),
                                      str("sdh")
                                    )
                                )
                            ),
                            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),
                                    a(str("lmi-type"), arg)
                                )
                            ),
                            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),
                                    a(str("action-red-differential-delay"), arg),
                                    a(str("fragment-threshold"), arg),
                                    a(str("drop-timeout"), arg),
                                    b(str("link-layer-overhead"),
                                      unsigned_float
                                    ),
                                    a(str("lmi-type"), arg),
                                    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_unicaset
                            ),
                            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(
                                    str("per-unit-mac-disable")
                                )
                            ),
                            b(str("aggregated-sonet-options"),
                                c(
                                    a(str("minimum-links"), arg),
                                    a(str("link-speed"), arg),
                                    a(str("minimum-bandwidth"), arg)
                                )
                            ),
                            b(str("atm-options"),
                                c(
                                    a(str("pic-type"), arg),
                                    a(str("cell-bundle-size"), 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"),
                                                c(
                                                    c(
                                                      a(str("oam-period"), arg),
                                                      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),
                                        c(
                                            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(
                                            a(str("vc-cos-mode"), arg),
                                            b(a(str("forwarding-class"), arg),
                                                c(
                                                    a(str("priority"), arg),
                                                    b(str("transmit-weight"),
                                                        c(
                                                            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"),
                                    b(str("flow-control-options"),
                                        c(
                                            str("dump-on-flow-control"),
                                            str("reset-on-flow-control"),
                                            str("down-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
                            ),
                            str("redundancy-options"),
                            str("load-balancing-options"),
                            str("lsq-failure-options"),
                            b(str("services-options"),
                                c(
                                    b(str("syslog"),
                                      service_set_syslog_object
                                    ),
                                    a(str("open-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),
                                    str("trio-flow-offload"),
                                    str("cgn-pic"),
                                    b(str("session-limit"),
                                        c(
                                            a(str("maximum"), arg),
                                            a(str("rate"), arg)
                                        )
                                    ),
                                    b(str("ignore-errors"),
                                        c(
                                            str("tcp"),
                                            str("alg")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("t3-options"),
                                c(
                                    a(str("loopback"), arg),
                                    str("long-buildout"),
                                    str("no-long-buildout"),
                                    str("loop-timing"),
                                    str("no-loop-timing"),
                                    str("unframed"),
                                    str("no-unframed"),
                                    b(str("compatibility-mode"),
                                        c(
                                            c(
                                              b(str("larscom"),
                                                  c(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("verilink"),
                                                  c(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("adtran"),
                                                  c(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("kentrox"),
                                                  c(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("digital-link"),
                                                  c(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    ).as(:oneline),
                                    str("payload-scrambler"),
                                    str("no-payload-scrambler"),
                                    str("cbit-parity"),
                                    str("no-cbit-parity"),
                                    a(str("fcs"), arg),
                                    a(str("idle-cycle-flag"), arg),
                                    a(str("start-end-flag"), arg),
                                    str("feac-loop-respond"),
                                    str("no-feac-loop-respond"),
                                    a(str("bert-algorithm"), arg),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg),
                                    a(str("buildout"), arg),
                                    a(str("atm-encapsulation"), arg)
                                )
                            ),
                            b(str("e3-options"),
                                c(
                                    a(str("loopback"), arg),
                                    str("unframed"),
                                    str("no-unframed"),
                                    b(str("compatibility-mode"),
                                        c(
                                            c(
                                              str("larscom"),
                                              b(str("digital-link"),
                                                  c(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("kentrox"),
                                                  c(
                                                      a(str("subrate"), arg)
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    ).as(:oneline),
                                    str("payload-scrambler"),
                                    str("no-payload-scrambler"),
                                    a(str("fcs"), arg),
                                    a(str("idle-cycle-flag"), arg),
                                    str("invert-data"),
                                    a(str("start-end-flag"), arg),
                                    a(str("bert-algorithm"), arg),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg),
                                    a(str("buildout"), arg),
                                    a(str("atm-encapsulation"), arg),
                                    a(str("framing"), arg)
                                )
                            ),
                            b(str("e1-options"),
                                c(
                                    a(str("timeslots"), arg),
                                    a(str("loopback"), arg),
                                    a(str("framing"), arg),
                                    a(str("fcs"), arg),
                                    str("invert-data"),
                                    a(str("idle-cycle-flag"), arg),
                                    a(str("start-end-flag"), arg),
                                    a(str("bert-algorithm"), arg),
                                    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),
                                    a(str("loopback"), arg),
                                    a(str("buildout"), arg),
                                    a(str("byte-encoding"), arg),
                                    a(str("line-encoding"), arg),
                                    str("invert-data"),
                                    a(str("framing"), arg),
                                    a(str("fcs"), arg),
                                    a(str("idle-cycle-flag"), arg),
                                    a(str("start-end-flag"), arg),
                                    a(str("bert-algorithm"), arg),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg),
                                    str("remote-loopback-respond"),
                                    a(str("crc-major-alarm-threshold"), arg),
                                    a(str("crc-minor-alarm-threshold"), arg),
                                    a(str("alarm-compliance"), arg)
                                )
                            ),
                            b(str("ds0-options"),
                                c(
                                    a(str("loopback"), arg),
                                    a(str("byte-encoding"), arg),
                                    str("invert-data"),
                                    a(str("fcs"), arg),
                                    a(str("idle-cycle-flag"), arg),
                                    a(str("start-end-flag"), arg),
                                    a(str("bert-algorithm"), arg),
                                    a(str("bert-error-rate"), arg),
                                    a(str("bert-period"), arg)
                                )
                            ),
                            b(str("serial-options"),
                                c(
                                    a(str("line-protocol"), arg),
                                    c(
                                      b(str("dte-options"),
                                          c(
                                              str("ignore-all"),
                                              b(str("dtr"),
                                                  c(
                                                      c(
                                                        str("assert"),
                                                        str("de-assert"),
                                                        str("normal"),
                                                        b(str("auto-synchronize"),
                                                            c(
                                                                a(str("duration"), arg),
                                                                a(str("interval"), arg)
                                                            )
                                                        )
                                                      )
                                                  )
                                              ).as(:oneline),
                                              a(str("control-signal"), arg),
                                              a(str("rts"), arg),
                                              a(str("dcd"), arg),
                                              a(str("dsr"), arg),
                                              a(str("cts"), arg),
                                              a(str("indication"), arg),
                                              a(str("tm"), arg)
                                          )
                                      ),
                                      b(str("dce-options"),
                                          c(
                                              str("ignore-all"),
                                              a(str("dtr"), arg),
                                              a(str("rts"), arg),
                                              a(str("dcd"), arg),
                                              a(str("dsr"), arg),
                                              a(str("cts"), arg),
                                              a(str("tm"), arg),
                                              str("dce-loopback-override")
                                          )
                                      )
                                    ),
                                    a(str("dtr-circuit"), arg),
                                    a(str("dtr-polarity"), arg),
                                    a(str("rts-polarity"), arg),
                                    a(str("control-polarity"), arg),
                                    a(str("dcd-polarity"), arg),
                                    a(str("dsr-polarity"), arg),
                                    a(str("cts-polarity"), arg),
                                    a(str("indication-polarity"), arg),
                                    a(str("tm-polarity"), arg),
                                    a(str("clocking-mode"), arg),
                                    a(str("transmit-clock"), arg),
                                    a(str("clock-rate"), arg),
                                    a(str("loopback"), arg),
                                    a(str("encoding"), arg),
                                    a(str("idle-cycle-flag"), arg)
                                )
                            ),
                            str("gratuitous-arp-reply"),
                            str("no-gratuitous-arp-reply"),
                            str("no-gratuitous-arp-request"),
                            str("no-no-gratuitous-arp-request"),
                            str("fibrechannel-options"),
                            b(str("ether-options") | str("gigether-options"),
                                c(
                                    str("loopback"),
                                    str("no-loopback"),
                                    str("flow-control"),
                                    str("no-flow-control"),
                                    str("source-filtering"),
                                    str("no-source-filtering"),
                                    c(
                                      str("no-auto-negotiation"),
                                      b(str("auto-negotiation"),
                                          c(
                                              a(str("remote-fault"), arg)
                                          )
                                      ).as(:oneline)
                                    ),
                                    a(str("mac-mode"), arg),
                                    str("asynchronous-notification"),
                                    a(str("source-address-filter"), arg).as(:oneline),
                                    b(str("redundant-parent"),
                                        c(
                                            b(str("parent"),
                                              interface_device
                                            )
                                        )
                                    ),
                                    b(str("802.3ad"),
                                      ca(
                                        b(str("lacp"),
                                          c(
                                            str("force-up"),
                                                    a(str("port-priority"), arg)
                                                )
                                            ),
                                            b(str("bundle"),
                                              interface_device
                                            ),
                                            a(str("link-index"), arg),
                                            c(
                                              str("primary"),
                                              str("backup")
                                            )
                                        )
                                    ),
                                    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
                                                    )
                                                )
                                            ),
                                            str("mac-learn-enable"),
                                            str("no-mac-learn-enable")
                                        )
                                    ),
                                    b(str("mpls"),
                                      mpls_ifd_options
                                    ),
                                    str("ignore-l3-incompletes"),
                                    str("no-auto-mdix")
                                )
                            ),
                            b(str("optics-options"),
                                c(
                                    a(str("wavelength"), arg),
                                    a(str("alarm"), str("low-light-alarm"),
                                        c(
                                            c(
                                              str("syslog"),
                                              str("link-down")
                                            )
                                        )
                                    ),
                                    a(str("warning"), str("low-light-warning"),
                                        c(
                                            c(
                                              str("syslog"),
                                              str("link-down")
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("otn-options"),
                              otn_options_type
                            ),
                            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(
                                            b(str("parent"),
                                              interface_device
                                            )
                                        )
                                    ),
                                    b(str("802.3ad"),
                                      ca(
                                        b(str("lacp"),
                                          c(
                                            str("force-up"),
                                                    a(str("port-priority"), arg)
                                                )
                                            ),
                                            b(str("bundle"),
                                              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),
                                    a(str("link-speed"), arg),
                                    a(str("minimum-links"), arg),
                                    b(str("lacp"),
                                        c(
                                            c(
                                              str("active"),
                                              str("passive")
                                            ),
                                            a(str("periodic"), arg)
                                        )
                                    )
                                )
                            ),
                            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("link-protection"),
                                    str("no-link-protection"),
                                    str("source-address-filter").as(:oneline),
                                    a(str("minimum-links"), arg),
                                    str("logical-interface-fpc-redundancy"),
                                    b(str("rebalance-periodic"),
                                        c(
                                            b(str("start-time"),
                                              time
                                            ),
                                            a(str("interval"), arg)
                                        )
                                    ),
                                    a(str("link-speed"), arg),
                                    b(str("lacp"),
                                        c(
                                            c(
                                              str("active"),
                                              str("passive")
                                            ),
                                            a(str("periodic"), arg),
                                            b(str("link-protection"),
                                                c(
                                                    str("disable"),
                                                    c(
                                                      str("revertive"),
                                                      str("non-revertive")
                                                    )
                                                )
                                            ),
                                            a(str("system-priority"), arg),
                                            b(str("system-id"),
                                              mac_addr
                                            ),
                                            a(str("admin-key"), arg)
                                        )
                                    ),
                                    b(str("ethernet-switch-profile"),
                                        c(
                                            a(str("tag-protocol-id"), arg)
                                        )
                                    ),
                                    str("mc-ae")
                                )
                            ),
                            b(str("es-options"),
                                c(
                                    b(str("backup-interface"),
                                      interface_device
                                    )
                                )
                            ),
                            b(str("dsl-options"),
                                c(
                                    a(str("operating-mode"), arg)
                                )
                            ),
                            b(str("vdsl-options"),
                                c(
                                    a(str("vdsl-profile"), arg)
                                )
                            ),
                            b(str("shdsl-options"),
                                c(
                                    a(str("annex"), arg),
                                    a(str("line-rate"), arg),
                                    a(str("loopback"), arg),
                                    b(str("snr-margin"),
                                        c(
                                            a(str("current"), arg),
                                            a(str("snext"), 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"),
                                            a(str("link-mode"), arg),
                                            a(str("speed"), arg),
                                            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(
                                                      a(str("member-interface-speed"), arg)
                                                  )
                                              ),
                                              b(str("atm"),
                                                  c(
                                                      a(str("member-interface-speed"), arg)
                                                  )
                                              )
                                            )
                                        )
                                    ),
                                    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("allow-configuration-override")
                                )
                            ),
                            str("layer2-policer"),
                            a(str("unit"), arg | arg | str("interface-unit-number"),
                                c(
                                    b(str("peer-psd"),
                                        c(
                                            a(str("psd-name"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("peer-interface"),
                                        c(
                                            b(str("interface-name"),
                                              interface_unit
                                            )
                                        )
                                    ),
                                    b(str("interface-shared-with"),
                                        c(
                                            a(str("psd-name"), arg)
                                        )
                                    ),
                                    c(
                                      str("disable")
                                    ),
                                    str("passive-monitor-mode"),
                                    str("per-session-scheduler"),
                                    str("clear-dont-fragment-bit"),
                                    str("reassemble-packets"),
                                    str("rpm"),
                                    a(str("description"), quote | arg),
                                    a(str("metadata"), arg),
                                    str("dial-options"),
                                    b(str("demux-source"),
                                          (str("inet") | str("inet6"))
                                    ),
                                    b(str("demux-destination"),
                                          (str("inet") | str("inet6"))
                                    ),
                                    a(str("encapsulation"), arg),
                                    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"),
                                    b(str("arp-resp"),
                                        c(
                                            c(
                                              str("unrestricted"),
                                              str("restricted")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("proxy-arp"),
                                        c(
                                            c(
                                              str("unrestricted"),
                                              str("restricted")
                                            )
                                        )
                                    ).as(:oneline),
                                    c(
                                      a(str("vlan-id"), arg),
                                      a(str("vlan-id-range"), arg),
                                      a(str("vlan-id-list"), arg),
                                      b(str("vlan-tags"),
                                          c(
                                              a(str("outer"), arg),
                                              c(
                                                a(str("inner"), arg),
                                                a(str("inner-range"), arg),
                                                a(str("inner-list"), arg)
                                              )
                                          )
                                      ).as(:oneline)
                                    ),
                                    a(str("native-inner-vlan-id"), arg),
                                    str("inner-vlan-id-range").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"),
                                        c(
                                            c(
                                              str("cell"),
                                              str("aal5")
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("vci-range"),
                                        c(
                                            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"),
                                        c(
                                            c(
                                              a(str("oam-period"), arg),
                                              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("demux-options"),
                                      demux_options_type
                                    ),
                                    str("targetted-distribution"),
                                    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),
                                    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),
                                                    a(str("queues"), arg),
                                                    b(str("port"),
                                                        c(
                                                            a(str("minimum"), arg),
                                                            a(str("maximum"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    b(str("maximum-contexts"),
                                                        c(
                                                            a(str("number"), 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("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
                                    ),
                                    str("atm-policer"),
                                    str("layer2-policer"),
                                    str("filter"),
                                    b(str("multi-chassis-protection"),
                                      multi_chassis_protection_group
                                    ),
                                    b(str("family"),
                                        c(
                                            b(str("inet"),
                                                c(
                                                    b(str("targeted-broadcast"),
                                                        c(
                                                            c(
                                                              str("forward-and-send-to-re"),
                                                              str("forward-only")
                                                            )
                                                        )
                                                    ),
                                                    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")
                                                        )
                                                    ),
                                                    a(str("mac-validate"), arg),
                                                    b(str("rpf-check"),
                                                        c(
                                                            a(str("fail-filter"), arg),
                                                            b(str("mode"),
                                                                c(
                                                                    str("loose")
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    a(str("mtu"), arg),
                                                    str("no-redirects"),
                                                    str("no-neighbor-learn"),
                                                    str("unconditional-src-learn"),
                                                    str("multicast-only"),
                                                    str("primary"),
                                                    a(str("ipsec-sa"), arg),
                                                    str("demux-source"),
                                                    str("demux-destination"),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              b(str("input"),
                                                                  ca(
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            c(
                                                              b(str("output"),
                                                                  ca(
                                                                      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),
                                                                    a(str("output-precedence"), arg)
                                                                )
                                                            ),
                                                            a(str("group"), arg),
                                                            a(str("dialer"), arg)
                                                        )
                                                    ),
                                                    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(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"),
                                                                        c(
                                                                            c(
                                                                              a(str("oam_period"), arg),
                                                                              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),
                                                                c(
                                                                    b(str("l2-interface"),
                                                                      interface_name
                                                                    ),
                                                                    c(
                                                                      b(str("mac"),
                                                                        mac_unicaset
                                                                      ),
                                                                      b(str("multicast-mac"),
                                                                        mac_multicast
                                                                      )
                                                                    ),
                                                                    str("publish")
                                                                )
                                                            ).as(:oneline),
                                                            b(str("web-authentication"),
                                                                c(
                                                                    str("http"),
                                                                    str("https"),
                                                                    str("redirect-to-https")
                                                                )
                                                            ),
                                                            b(str("vrrp-group"),
                                                              vrrp_group
                                                            )
                                                        )
                                                    ),
                                                    b(str("unnumbered-address"),
                                                        c(
                                                            b(str("source"),
                                                              interface_unit
                                                            ),
                                                            a(str("preferred-source-address"), arg),
                                                            b(str("destination"),
                                                              ipv4addr
                                                            ),
                                                            a(str("destination-profile"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    str("location-pool-address"),
                                                    str("negotiate-address"),
                                                    b(str("dhcp"),
                                                        c(
                                                            b(str("client-identifier"),
                                                                c(
                                                                    c(
                                                                      a(str("ascii"), arg),
                                                                      a(str("hexadecimal"), arg)
                                                                    )
                                                                )
                                                            ).as(:oneline),
                                                            a(str("lease-time"), arg),
                                                            a(str("retransmission-attempt"), arg),
                                                            a(str("retransmission-interval"), arg),
                                                            b(str("server-address"),
                                                              ipv4addr
                                                            ),
                                                            str("update-server"),
                                                            a(str("vendor-id"), arg)
                                                        )
                                                    ),
                                                    b(str("dhcp-client"),
                                                      dhcp_client_type
                                                    )
                                                )
                                            ),
                                            b(str("iso"),
                                                c(
                                                    a(str("address"), arg),
                                                    a(str("mtu"), arg)
                                                )
                                            ),
                                            b(str("inet6"),
                                                c(
                                                    b(str("rpf-check"),
                                                        c(
                                                            a(str("fail-filter"), arg),
                                                            b(str("mode"),
                                                                c(
                                                                    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("nd6-stale-time"), arg),
                                                    str("no-neighbor-learn"),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              b(str("input"),
                                                                  ca(
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            c(
                                                              b(str("output"),
                                                                  ca(
                                                                      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),
                                                                    a(str("output-precedence"), arg)
                                                                )
                                                            ),
                                                            a(str("group"), arg),
                                                            a(str("dialer"), arg)
                                                        )
                                                    ),
                                                    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(a(str("address"), arg),
                                                        c(
                                                            b(str("destination"),
                                                              ipv6addr
                                                            ),
                                                            str("eui-64"),
                                                            str("primary"),
                                                            str("preferred"),
                                                            str("master-only"),
                                                            b(a(str("ndp"), arg),
                                                                c(
                                                                    b(str("l2-interface"),
                                                                      interface_name
                                                                    ),
                                                                    c(
                                                                      b(str("mac"),
                                                                        mac_unicaset
                                                                      ),
                                                                      b(str("multicast-mac"),
                                                                        mac_multicast
                                                                      )
                                                                    ),
                                                                    str("publish")
                                                                )
                                                            ).as(:oneline),
                                                            b(str("vrrp-inet6-group"),
                                                              vrrp_group
                                                            ),
                                                            b(str("web-authentication"),
                                                                c(
                                                                    str("http"),
                                                                    str("https"),
                                                                    str("redirect-to-https")
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    str("demux-source"),
                                                    str("demux-destination"),
                                                    b(str("unnumbered-address"),
                                                        c(
                                                            b(str("source"),
                                                              interface_unit
                                                            ),
                                                            a(str("preferred-source-address"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    str("dad-disable"),
                                                    str("no-dad-disable"),
                                                    b(str("dhcpv6-client"),
                                                        c(
                                                            a(str("client-type"), arg),
                                                            a(str("client-ia-type"), str("ia-na") | str("ia-pd")),
                                                            str("rapid-commit"),
                                                            b(str("update-router-advertisement"),
                                                                c(
                                                                    a(str("interface"), arg)
                                                                )
                                                            ),
                                                            b(str("client-identifier"),
                                                                c(
                                                                    a(str("duid-type"), arg)
                                                                )
                                                            ).as(:oneline),
                                                            a(str("req-option"), 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("update-server"),
                                                            a(str("retransmission-attempt"), 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)
                                                            ),
                                                            c(
                                                              a(str("output"), arg),
                                                              a(str("output-list"), arg)
                                                            ),
                                                            a(str("group"), arg),
                                                            a(str("dialer"), arg)
                                                        )
                                                    ),
                                                    a(str("input-hierarchical-policer"), arg),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("mlppp"),
                                                c(
                                                    b(str("bundle"),
                                                      interface_unit
                                                    )
                                                )
                                            ),
                                            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(
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              a(str("input"), arg),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            c(
                                                              a(str("output"), arg),
                                                              a(str("output-list"), arg)
                                                            ),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    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
                                                            )
                                                        )
                                                    ),
                                                    str("protocols")
                                                )
                                            ),
                                            b(str("vpls"),
                                                c(
                                                    str("core-facing"),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              b(str("input"),
                                                                  ca(
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            c(
                                                              b(str("output"),
                                                                  ca(
                                                                      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),
                                                                    a(str("output-precedence"), arg)
                                                                )
                                                            ),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("bridge"),
                                                c(
                                                    str("core-facing"),
                                                    b(str("filter"),
                                                        c(
                                                            c(
                                                              b(str("input"),
                                                                  ca(
                                                                      a(str("precedence"), arg)
                                                                  )
                                                              ).as(:oneline),
                                                              a(str("input-list"), arg)
                                                            ),
                                                            c(
                                                              b(str("output"),
                                                                  ca(
                                                                      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),
                                                                    a(str("output-precedence"), arg)
                                                                )
                                                            ),
                                                            a(str("group"), arg)
                                                        )
                                                    ),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("input"), arg),
                                                            a(str("output"), arg)
                                                        )
                                                    ),
                                                    a(str("interface-mode"), arg),
                                                    a(str("bridge-domain-type"), arg),
                                                    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),
                                                                c(
                                                                    a(str("to-vlan-id"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    c(
                                                      a(str("isid-list"), arg)
                                                    ),
                                                    b(str("storm-control"),
                                                      storm_control
                                                    )
                                                )
                                            ),
                                            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)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    a(str("service-domain"), arg),
                                    str("copy-tos-to-outer-ip-header"),
                                    b(str("dialer-options"),
                                        c(
                                            a(str("pool"), arg),
                                            a(str("dial-string"), arg),
                                            b(str("incoming-map"),
                                                c(
                                                    c(
                                                      a(str("caller"), arg).as(:oneline),
                                                      str("accept-all")
                                                    )
                                                )
                                            ),
                                            str("callback"),
                                            a(str("callback-wait-period"), arg),
                                            a(str("redial-delay"), arg),
                                            a(str("idle-timeout"), arg),
                                            a(str("watch-list"), arg),
                                            a(str("load-threshold"), arg),
                                            a(str("load-interval"), arg),
                                            a(str("activation-delay"), arg),
                                            a(str("deactivation-delay"), arg),
                                            a(str("initial-route-check"), arg)
                                        )
                                    ),
                                    b(str("backup-options"),
                                        c(
                                            b(str("interface"),
                                              interface_name
                                            )
                                        )
                                    ),
                                    str("dynamic-call-admission-control")
                                )
                            ),
                            b(str("no-partition"),
                                c(
                                    a(str("interface-type"), arg)
                                )
                            ).as(:oneline),
                            b(a(str("partition"), arg),
                                c(
                                    a(str("oc-slice"), arg),
                                    a(str("timeslots"), arg),
                                    a(str("interface-type"), arg)
                                )
                            ).as(:oneline),
                            b(str("modem-options"),
                                c(
                                    a(str("init-command-string"), arg),
                                    a(str("dialin"), arg)
                                )
                            ),
                            b(str("isdn-options"),
                                c(
                                    a(str("switch-type"), arg),
                                    a(str("media-type"), arg),
                                    a(str("spid1"), arg),
                                    a(str("spid2"), arg),
                                    a(str("calling-number"), arg),
                                    b(a(str("incoming-called-number"), arg),
                                        c(
                                            str("reject")
                                        )
                                    ).as(:oneline),
                                    a(str("tei-option"), arg),
                                    a(str("static-tei-val"), arg),
                                    a(str("t310"), arg),
                                    a(str("bchannel-allocation"), arg)
                                )
                            ),
                            b(str("dialer-options"),
                                c(
                                    b(a(str("pool"), arg),
                                        c(
                                            a(str("priority"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("redundant-pseudo-interface-options"),
                                c(
                                    a(str("redundancy-group"), arg)
                                )
                            ),
                            str("cellular-options")
                        )
                    ),
                    interfaces_type
                )
            ),
            b(str("protocols"),
                c(
                    b(str("igmp"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), 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"),
                                        c(
                                            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 | str("interface-name"),
                                c(
                                    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),
                                    b(str("passive"),
                                        c(
                                            str("allow-receive"),
                                            str("send-general-query"),
                                            str("send-group-query")
                                        )
                                    ).as(:oneline),
                                    b(str("oif-map"),
                                      policy_algebra
                                    )
                                )
                            )
                        )
                    ),
                    b(str("oam"),
                        c(
                            b(str("ethernet"),
                                c(
                                    b(str("link-fault-management"),
                                        c(
                                            b(str("traceoptions"),
                                                c(
                                                    str("no-remote-trace"),
                                                    b(str("file"),
                                                        sca(
                                                            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"), 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),
                                                    a(str("link-discovery"), arg),
                                                    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(
                                            str("performance-monitoring"),
                                            str("connection-protection"),
                                            b(str("traceoptions"),
                                              cfm_traceoptions
                                            ),
                                            b(a(str("action-profile"), arg),
                                                c(
                                                    b(str("event"),
                                                        c(
                                                            str("adjacency-loss"),
                                                            str("rdi"),
                                                            a(str("connection-protection-tlv"), arg)
                                                        )
                                                    ),
                                                    b(str("action"),
                                                        c(
                                                            str("interface-down"),
                                                            str("propagate-remote-mac-flush")
                                                        )
                                                    ),
                                                    b(str("clear-action"),
                                                        c(
                                                            b(str("interface-down"),
                                                                c(
                                                                    str("peer-interface")
                                                                )
                                                            ).as(:oneline),
                                                            str("propagate-remote-mac-flush")
                                                        )
                                                    ),
                                                    b(str("default-actions"),
                                                        c(
                                                            str("interface-down")
                                                        )
                                                    )
                                                )
                                            ),
                                            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),
                                                    a(str("age"), arg)
                                                )
                                            ),
                                            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") | str("md-name"),
                                                c(
                                                    b(a(str("bridge-domain"), arg),
                                                        c(
                                                            a(str("vlan-id"), arg)
                                                        )
                                                    ).as(:oneline),
                                                    b(a(str("virtual-switch"), arg),
                                                        c(
                                                            b(a(str("bridge-domain"), arg),
                                                                c(
                                                                    a(str("vlan-id"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    a(str("instance"), arg).as(:oneline),
                                                    a(str("interface"), arg).as(:oneline),
                                                    a(str("level"), arg),
                                                    a(str("name-format"), arg),
                                                    a(str("mip-half-function"), arg),
                                                    b(a(str("maintenance-association"), arg),
                                                        c(
                                                            a(str("short-name-format"), arg),
                                                            str("protect-maintenance-association").as(:oneline),
                                                            a(str("primary-vid"), arg),
                                                            b(str("continuity-check"),
                                                                c(
                                                                    a(str("interval"), arg),
                                                                    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")
                                                                )
                                                            ),
                                                            a(str("mip-half-function"), arg),
                                                            b(a(str("mep"), arg),
                                                                c(
                                                                    b(str("interface"),
                                                                        c(
                                                                            b(str("interface-name"),
                                                                              interface_unit
                                                                            ),
                                                                            a(str("vlan"), arg),
                                                                            c(
                                                                              str("working"),
                                                                              str("protect")
                                                                            ),
                                                                            a(str("vlan-id"), arg)
                                                                        )
                                                                    ).as(:oneline),
                                                                    a(str("direction"), arg),
                                                                    a(str("priority"), arg),
                                                                    str("auto-discovery"),
                                                                    b(a(str("remote-mep"), arg),
                                                                        c(
                                                                            a(str("action-profile"), arg),
                                                                            b(a(str("sla-iterator-profile"), arg),
                                                                                c(
                                                                                    a(str("iteration-count"), arg),
                                                                                    a(str("priority"), arg),
                                                                                    a(str("data-tlv-size"), arg)
                                                                                )
                                                                            )
                                                                        )
                                                                    ),
                                                                    a(str("lowest-priority-defect"), arg)
                                                                )
                                                            ),
                                                            b(str("policer"),
                                                                c(
                                                                    a(str("continuity-check"), arg),
                                                                    a(str("other"), arg),
                                                                    a(str("all"), arg)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    a(str("vlan-name"), arg)
                                                )
                                            ),
                                            b(str("esp-traceoptions"),
                                                c(
                                                    b(str("file"),
                                                      esp_trace_file_type
                                                    ),
                                                    a(str("flag"), str("krt") | str("error") | str("esp") | str("normal") | str("task") | str("lib") | str("timer") | str("interface") | str("all"),
                                                        c(
                                                            str("disable")
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("evcs"), arg),
                                        c(
                                            b(str("evc-protocol"),
                                                c(
                                                    c(
                                                      b(str("cfm"),
                                                          c(
                                                              a(str("maintenance-domain"), arg),
                                                              a(str("maintenance-association"), arg)
                                                          )
                                                      ).as(:oneline),
                                                      b(str("vpls"),
                                                          c(
                                                              a(str("routing-instance"), arg)
                                                          )
                                                      ).as(:oneline)
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("remote-uni-count"), arg),
                                            str("multipoint-to-multipoint")
                                        )
                                    ),
                                    b(str("lmi"),
                                        c(
                                            b(str("traceoptions"),
                                                c(
                                                    str("no-remote-trace"),
                                                    b(str("file"),
                                                        sca(
                                                            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"), 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),
                                                    a(str("evc-map-type"), arg),
                                                    b(a(str("evc"), arg),
                                                        c(
                                                            str("default-evc"),
                                                            a(str("vlan-list"), arg)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            str("gre-tunnel")
                        )
                    ),
                    b(str("mld"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), 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"),
                                        c(
                                            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 | str("interface-name"),
                                c(
                                    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),
                                    str("accounting"),
                                    str("no-accounting"),
                                    b(str("passive"),
                                        c(
                                            str("allow-receive"),
                                            str("send-general-query"),
                                            str("send-group-query")
                                        )
                                    ).as(:oneline),
                                    b(str("oif-map"),
                                      policy_algebra
                                    )
                                )
                            )
                        )
                    ),
                    b(str("router-advertisement"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")).as(:oneline)
                                )
                            ),
                            a(str("interface"), arg | str("interface-name"),
                                c(
                                    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"),
                                    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),
                                    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("class-of-service"),
              juniper_class_of_service_options
            ),
            b(str("routing-options"),
                c(
                    b(a(str("rib"), arg),
                        c(
                            b(str("static"),
                                c(
                                    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"),
                                            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"),
                                              ca(
                                                    a(str("origin"), arg),
                                                    str("atomic-aggregate"),
                                                    b(str("aggregator"),
                                                        ca(
                                                            b(str("address"),
                                                              ipv4addr
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    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
                                            ),
                                            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
                                            ),
                                            a(str("backup-pe-group"), arg),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    a(str("version"), arg),
                                                    a(str("minimum-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),
                                                            a(str("algorithm"), arg),
                                                            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"),
                                            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"),
                                              ca(
                                                    a(str("origin"), arg),
                                                    str("atomic-aggregate"),
                                                    b(str("aggregator"),
                                                        ca(
                                                            b(str("address"),
                                                              ipv4addr
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    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
                                            ),
                                            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
                                            ),
                                            a(str("backup-pe-group"), arg),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    a(str("version"), arg),
                                                    a(str("minimum-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),
                                                            a(str("algorithm"), arg),
                                                            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"),
                                            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"),
                                              ca(
                                                    a(str("origin"), arg),
                                                    str("atomic-aggregate"),
                                                    b(str("aggregator"),
                                                        ca(
                                                            b(str("address"),
                                                              ipv4addr
                                                            )
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("martians"),
                              martian_type
                            ),
                            b(str("aggregate"),
                              rib_aggregate_type
                            ),
                            b(str("generate"),
                              rib_aggregate_type
                            ),
                            c(
                              b(str("maximum-paths"),
                                  c(
                                      a(str("limit"), arg),
                                      c(
                                        a(str("threshold"), arg),
                                        str("log-only")
                                      ),
                                      a(str("log-interval"), arg)
                                  )
                              ).as(:oneline)
                            ),
                            b(str("maximum-prefixes"),
                                c(
                                    a(str("limit"), 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"),
                                        c(
                                            str("equal-external-internal")
                                        )
                                    ).as(:oneline),
                                    str("as-path-compare")
                                )
                            ),
                            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)
                                        )
                                    )
                                )
                            ),
                            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("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)
                                )
                            )
                        )
                    ),
                    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"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), str("parse") | str("config-internal") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                        c(
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            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"),
                                        c(
                                            a(str("bandwidth-value"), arg),
                                            str("adaptive")
                                        )
                                    ).as(:oneline),
                                    b(str("redundant-sources"),
                                      ipaddr
                                    ),
                                    b(str("forwarding-cache"),
                                        c(
                                            b(str("timeout"),
                                                c(
                                                    c(
                                                      a(str("timeout-value"), arg),
                                                      b(str("never"),
                                                          c(
                                                              str("non-discard-entry-only")
                                                          )
                                                      )
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            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(
                                    b(str("threshold"),
                                        c(
                                            a(str("suppress"), arg),
                                            a(str("reuse"), 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(a(str("backup-pe-group"), arg),
                                c(
                                    b(str("backups"),
                                      ipaddr
                                    ),
                                    b(str("local-address"),
                                      ipaddr
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            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("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("mpls"),
                                c(
                                    b(str("dialer-filter"),
                                      mpls_dialer_filter
                                    ),
                                    b(str("filter"),
                                      mpls_filter
                                    )
                                )
                            ),
                            b(str("vpls"),
                                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
                                    )
                                )
                            ),
                            str("ethernet-switching")
                        )
                    ),
                    b(str("policer"),
                      firewall_policer
                    ),
                    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("profile-variable-set"),
              juniper_dynamic_profile_varset_object
            ),
            b(str("policy-options"),
                c(
                    b(a(str("prefix-list"), arg),
                        c(
                            prefix_list_items,
                            a(str("apply-path"), arg)
                        )
                    )
                )
            )
        )
      )
    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-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-excess-priority") | str("interface-set-name") | str("cos-adjust-minimum") | str("cos-excess-rate-high") | str("cos-excess-rate-low") | str("cos-shaping-rate-burst") | str("cos-guaranteed-rate-burst")).as(:arg),
        c(
            a(str("default-value"), arg)
        )
      )
    end

    rule(:cfm_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    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"), str("configuration") | str("routing-socket") | str("protocol") | str("init") | str("error") | str("issu") | str("all")).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

    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-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_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"),
                        c(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("voip"),
                c(
                    a(str("interface"), arg | 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(
                    a(str("ether-type"), arg)
                )
            ),
            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),
                                c(
                                    b(str("next-hop"),
                                      interface_name
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("secure-access-port"),
                c(
                    b(a(str("interface"), arg),
                        c(
                            b(str("mac-limit"),
                                c(
                                    a(str("limit"), arg),
                                    a(str("action"), arg)
                                )
                            ).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"),
                                  c(
                                      a(str("forwarding-class"), arg)
                                  )
                              ).as(:oneline),
                              str("no-arp-inspection")
                            ),
                            c(
                              b(str("examine-dhcp"),
                                  c(
                                      a(str("forwarding-class"), arg)
                                  )
                              ).as(:oneline),
                              str("no-examine-dhcp")
                            ),
                            str("examine-fip"),
                            b(str("mac-move-limit"),
                                c(
                                    a(str("limit"), arg),
                                    a(str("action"), arg)
                                )
                            ).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),
            a(str("loss-priority"), arg),
            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_egress_interface_type) do
      (arg | str("all")).as(:arg)
    end

    rule(:analyzer_ingress_type) do
        c(
            b(str("interface"),
              analyzer_ingress_interface_type
            ),
            b(str("vlan"),
              analyzer_vlan_type
            )
        )
    end

    rule(:analyzer_ingress_interface_type) do
      (arg | str("all")).as(:arg)
    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(:dhcp_option82_type) do
        c(
            str("disable"),
            b(str("circuit-id"),
                c(
                    a(str("prefix"), arg),
                    str("use-interface-description"),
                    str("use-vlan-id")
                )
            ),
            b(str("remote-id"),
                c(
                    a(str("prefix"), arg),
                    str("use-interface-description"),
                    a(str("use-string"), arg)
                )
            ),
            b(str("vendor-id"),
                c(
                    a(str("use-string"), arg)
                )
            )
        )
    end

    rule(:esw_interface_type) do
      b(arg.as(:arg),
        c(
            str("no-mac-learning")
        )
      )
    end

    rule(:juniper_forwarding_options) do
        c(
            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("load-balance"),
                c(
                    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"),
                c(
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("layer-3"),
                                        c(
                                            str("destination-address")
                                        )
                                    ),
                                    str("layer-4"),
                                    str("session-id"),
                                    str("symmetric-hash")
                                )
                            ),
                            b(str("mpls"),
                                c(
                                    str("label-1"),
                                    str("label-2"),
                                    str("label-3"),
                                    str("no-labels"),
                                    str("no-label-1-exp"),
                                    b(str("payload"),
                                        c(
                                            str("ether-pseudowire"),
                                            b(str("ip"),
                                                c(
                                                    c(
                                                      str("layer-3-only"),
                                                      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"),
                                    str("payload"),
                                    str("symmetric-hash")
                                )
                            )
                        )
                    )
                )
            ),
            str("enhanced-hash-key"),
            str("rpf-loose-mode-discard"),
            b(str("helpers"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sca(
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("level"), arg),
                            a(str("flag"), str("trace") | str("address") | str("main") | str("config") | str("ifdb") | str("io") | str("rtsock") | str("ui") | str("util") | 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"), str("init") | str("routing-socket") | str("map") | str("all"),
                                        c(
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("domain"),
                        c(
                            a(str("description"), quote | arg),
                            b(str("server"),
                                c(
                                    b(str("address"),
                                      ipv4addr
                                    ),
                                    c(
                                      b(str("logical-system"),
                                          c(
                                              a(str("logical-system-name"), 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"),
                                        c(
                                            b(str("address"),
                                              ipv4addr
                                            ),
                                            c(
                                              b(str("logical-system"),
                                                  c(
                                                      a(str("logical-system-name"), 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"),
                                c(
                                    b(str("address"),
                                      ipv4addr
                                    ),
                                    c(
                                      b(str("logical-system"),
                                          c(
                                              a(str("logical-system-name"), 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"),
                                        c(
                                            b(str("address"),
                                              ipv4addr
                                            ),
                                            c(
                                              b(str("logical-system"),
                                                  c(
                                                      a(str("logical-system-name"), 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),
                                        c(
                                            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(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),
                                                c(
                                                    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
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("port"), arg),
                        c(
                            a(str("description"), quote | arg),
                            b(str("server"),
                                c(
                                    b(str("address"),
                                      ipv4addr
                                    ),
                                    c(
                                      b(str("logical-system"),
                                          c(
                                              a(str("logical-system-name"), 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"),
                                        c(
                                            b(str("address"),
                                              ipv4addr
                                            ),
                                            c(
                                              b(str("logical-system"),
                                                  c(
                                                      a(str("logical-system-name"), arg),
                                                      a(str("routing-instance"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("routing-instance"), arg)
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            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")
                        )
                    ),
                    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("next-hop-group"),
              juniper_next_hop_group_options
            ),
            b(str("dhcp-relay"),
              jdhcp_relay_type
            ),
            a(str("fast-reroute-priority"), arg),
            str("cut-through"),
            str("ipmc-miss-do-l2mc"),
            b(a(str("storm-control-profiles"), arg),
              c(
                str("action-shutdown"),
                b(str("all"),
                  c(
                    a(str("bandwidth-level"), arg),
                    a(str("bandwidth-percentage"), arg),
                    str("no-broadcast"),
                    str("no-multicast"),
                    str("no-registered-multicast"),
                    str("no-unknown-unicast"),
                    str("no-unregistered-multicast")
                  )
                )
              )
            )
        )
    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(:juniper_logical_system) do
      b(arg.as(:arg),
        c(
            b(str("interfaces"),
                c(
                    b(str("interface"),
                      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(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
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            str("instance")
                        )
                    )
                )
            ),
            b(str("system"),
                c(
                    b(str("services"),
                        c(
                            b(str("dhcp-local-server"),
                              jdhcp_local_server_type
                            ),
                            b(str("static-subscribers"),
                              jsscd_static_subscribers_type
                            )
                        )
                    )
                )
            ),
            b(str("access"),
                c(
                    b(str("address-assignment"),
                      address_assignment_type
                    ),
                    str("address-protection"),
                    b(str("firewall-authentication"),
                        c(
                            b(str("pass-through"),
                                c(
                                    a(str("default-profile"), arg),
                                    b(str("ftp"),
                                      banner_object
                                    ),
                                    b(str("telnet"),
                                      banner_object
                                    ),
                                    b(str("http"),
                                      banner_object
                                    )
                                )
                            ),
                            b(str("web-authentication"),
                                c(
                                    a(str("default-profile"), arg),
                                    b(str("banner"),
                                        c(
                                            a(str("success"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("configuration") | str("setup") | str("authentication") | str("all")).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("access-profile"),
                c(
                    a(str("access-profile-name"), 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("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("mpls"),
                                c(
                                    b(str("dialer-filter"),
                                      mpls_dialer_filter
                                    ),
                                    b(str("filter"),
                                      mpls_filter
                                    )
                                )
                            ),
                            b(str("vpls"),
                                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
                                    )
                                )
                            ),
                            str("ethernet-switching")
                        )
                    ),
                    b(str("policer"),
                      firewall_policer
                    ),
                    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("mobile-ip"),
                      juniper_protocols_mobile_ipv4
                    ),
                    b(str("flow-monitoring"),
                        c(
                            b(str("version9"),
                                c(
                                    b(str("template"),
                                      version9_template
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("bridge-domains"),
                c(
                    b(str("domain"),
                      juniper_bridge_domains
                    )
                )
            ),
            b(str("switch-options"),
              juniper_def_rtb_switch_options
            ),
            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(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"),
                            a(str("mode"), arg),
                            a(str("event-rate"), arg),
                            a(str("format"), arg),
                            a(str("rate-cap"), arg),
                            c(
                              b(str("source-address"),
                                ipaddr
                              ),
                              b(str("source-interface"),
                                interface_name
                              )
                            ),
                            b(str("transport"),
                                c(
                                    a(str("tcp-connections"), arg),
                                    a(str("protocol"), arg),
                                    a(str("tls-profile"), arg)
                                )
                            ),
                            b(a(str("stream"), arg),
                                c(
                                    a(str("severity"), arg),
                                    a(str("format"), arg),
                                    a(str("category"), arg),
                                    b(str("host"),
                                      host_object
                                    )
                                )
                            ),
                            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"),
                                        sca(
                                            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"), 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),
                                    a(str("encoding"), arg)
                                )
                            )
                        )
                    ),
                    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-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("idp"),
                        c(
                            b(str("idp-policy"),
                              idp_policy_type
                            ),
                            a(str("active-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
                                    ),
                                    b(str("install"),
                                        c(
                                            str("ignore-version-check")
                                        )
                                    ),
                                    b(str("automatic"),
                                        c(
                                            b(str("start-time"),
                                              time
                                            ),
                                            a(str("interval"), arg),
                                            c(
                                              str("enable")
                                            )
                                        )
                                    )
                                )
                            ),
                            b(str("sensor-configuration"),
                                c(
                                    b(str("log"),
                                        c(
                                            a(str("cache-size"), arg),
                                            b(str("suppression"),
                                                c(
                                                    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(
                                                    b(str("ipaddr"),
                                                      ipv4addr
                                                    ),
                                                    a(str("port"), arg)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("application-identification"),
                                        c(
                                            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-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)
                                        )
                                    ),
                                    b(str("re-assembler"),
                                        c(
                                            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-flow-mem"), arg),
                                            a(str("max-packet-mem-ratio"), arg),
                                            a(str("action-on-reassembly-failure"), arg),
                                            str("tcp-error-logging"),
                                            str("no-tcp-error-logging"),
                                            a(str("max-synacks-queued"), arg)
                                        )
                                    ),
                                    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("gtp"),
                                                c(
                                                    str("decapsulation"),
                                                    str("no-decapsulation")
                                                )
                                            )
                                        )
                                    ),
                                    b(str("detector"),
                                        c(
                                            b(str("protocol-name"),
                                              proto_object
                                            )
                                        )
                                    ),
                                    str("ssl-inspection"),
                                    str("disable-low-memory-handling"),
                                    b(str("high-availability"),
                                        c(
                                            str("no-policy-cold-synchronization")
                                        )
                                    ),
                                    b(str("security-configuration"),
                                        c(
                                            a(str("protection-mode"), arg)
                                        )
                                    )
                                )
                            ),
                            str("processes")
                        )
                    ),
                    b(str("ike"),
                      security_ike
                    ),
                    b(str("ipsec"),
                      security_ipsec_vpn
                    ),
                    b(str("group-vpn"),
                      security_group_vpn
                    ),
                    b(str("address-book"),
                      named_address_book_type
                    ),
                    b(str("alg"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            b(str("match"),
                                              regular_expression
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("level"), arg)
                                )
                            ),
                            b(str("alg-manager"),
                                c(
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ).as(:oneline),
                            b(str("alg-support-lib"),
                                c(
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ).as(:oneline),
                            b(str("dns"),
                                c(
                                    str("disable"),
                                    a(str("maximum-message-length"), arg),
                                    b(str("doctoring"),
                                        c(
                                            c(
                                              str("none"),
                                              str("sanity-check")
                                            )
                                        )
                                    ),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("ftp"),
                                c(
                                    str("disable"),
                                    str("ftps-extension"),
                                    str("line-break-extension"),
                                    str("allow-mismatch-ip-address"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    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"),
                                                        c(
                                                            a(str("threshold"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("dscp-rewrite"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("q931") | str("h245") | str("ras") | str("h225-asn1") | str("h245-asn1") | str("ras-asn1") | str("chassis-cluster") | str("all"),
                                                c(
                                                    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"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ).as(:oneline),
                                            b(str("connection-flood"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("dscp-rewrite"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("call") | str("decode") | str("error") | str("chassis-cluster") | str("nat") | str("packet") | str("rm") | str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("msrpc"),
                                c(
                                    str("disable"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ).as(:oneline),
                            b(str("sunrpc"),
                                c(
                                    str("disable"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ).as(:oneline),
                            b(str("rsh"),
                                c(
                                    str("disable"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ).as(:oneline),
                            b(str("rtsp"),
                                c(
                                    str("disable"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    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"),
                                                c(
                                                    a(str("threshold"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    b(str("dscp-rewrite"),
                                        c(
                                            a(str("code-point"), arg)
                                        )
                                    ),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("call") | str("cli") | str("decode") | str("error") | str("chassis-cluster") | str("init") | str("nat") | str("rm") | str("all"),
                                                c(
                                                    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("retain-hold-resource"),
                                    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"), str("call") | str("chassis-cluster") | str("nat") | str("parser") | str("rm") | str("all"),
                                                c(
                                                    c(
                                                      str("terse"),
                                                      str("detail"),
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("sql"),
                                c(
                                    str("disable"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ).as(:oneline),
                            b(str("talk"),
                                c(
                                    str("disable"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ).as(:oneline),
                            b(str("tftp"),
                                c(
                                    str("disable"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ).as(:oneline),
                            b(str("pptp"),
                                c(
                                    str("disable"),
                                    b(str("traceoptions"),
                                        c(
                                            a(str("flag"), str("all"),
                                                c(
                                                    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"), str("all"),
                                                c(
                                                    c(
                                                      str("extensive")
                                                    )
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("application-firewall"),
                    str("application-tracking"),
                    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("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("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
                            )
                        )
                    ),
                    str("dynamic-vpn"),
                    b(str("softwires"),
                        c(
                            b(str("softwire-name"),
                              softwire_option_type
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("configuration") | str("flow") | str("all")).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("forwarding-options"),
                        c(
                            b(str("family"),
                                c(
                                    b(str("inet6"),
                                        c(
                                            a(str("mode"), arg)
                                        )
                                    ),
                                    b(str("mpls"),
                                        c(
                                            a(str("mode"), arg)
                                        )
                                    ),
                                    b(str("iso"),
                                        c(
                                            a(str("mode"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("mirror-filter"),
                              mirror_filter_type
                            )
                        )
                    ),
                    str("advanced-services"),
                    b(str("flow"),
                        c(
                            str("enhanced-routing-mode"),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), 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")
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("pending-sess-queue-length"), arg),
                            str("allow-dns-reply"),
                            a(str("route-change-timeout"), arg),
                            a(str("syn-flood-protection-mode"), arg),
                            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("bridge"),
                                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("time-wait-state"),
                                        c(
                                            c(
                                              str("session-ageout"),
                                              a(str("session-timeout"), arg)
                                            ),
                                            str("apply-to-half-close-state")
                                        )
                                    )
                                )
                            ),
                            str("force-ip-reassembly"),
                            b(str("load-distribution"),
                                c(
                                    str("session-affinity")
                                )
                            )
                        )
                    ),
                    b(str("firewall-authentication"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    a(str("flag"), str("authentication") | str("proxy") | str("all"),
                                        c(
                                            c(
                                              str("terse"),
                                              str("detail"),
                                              str("extensive")
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("screen"),
                        c(
                            b(str("ids-option"),
                              ids_option_type
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("configuration") | str("flow") | str("all")).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("nat"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), 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"),
                                        c(
                                            str("syslog")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            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("forwarding-process"),
                    b(str("policies"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("configuration") | str("routing-socket") | str("compilation") | str("ipc") | str("rules") | str("lookup") | str("all")).as(:oneline)
                                )
                            ),
                            b(str("policy"),
                                s(
                                  a(str("from-zone-name"), arg),
                                  a(str("to-zone-name"), arg),
                                  c(
                                    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")
                                    )
                                )
                            ),
                            str("policy-rematch"),
                            b(str("policy-stats"),
                                c(
                                    a(str("system-wide"), arg)
                                )
                            )
                        )
                    ),
                    b(str("resource-manager"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    a(str("flag"), str("client") | str("group") | str("resource") | str("gate") | str("session") | str("chassis cluster") | str("messaging") | str("service pinhole") | str("error") | str("all"),
                                        c(
                                            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"),
                                sca(
                                    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"), str("configuration") | str("routing-socket") | str("compilation") | str("all")).as(:oneline),
                            a(str("rate-limit"), arg)
                        )
                    ),
                    str("datapath-debug"),
                    b(str("user-identification"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), 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("applications"),
                c(
                    b(str("application"),
                      application_object
                    ),
                    b(str("application-set"),
                      application_set_object
                    )
                )
            ),
            b(str("schedulers"),
                c(
                    b(str("scheduler"),
                      scheduler_object_type
                    )
                )
            )
        )
      )
    end

    rule(:cflowd_sampling_inet_lr_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("autonomous-system-type"), arg),
            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(: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_mpls_lr_type) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            a(str("autonomous-system-type"), arg),
            b(str("aggregation"),
              aggregation_type
            ),
            str("local-dump"),
            str("no-local-dump"),
            b(str("source-address"),
              ipv4addr
            ),
            str("version9")
        )
      )
    end

    rule(:jdhcp_local_server_type) do
        c(
            b(str("dhcpv6"),
              dhcpv6_local_server_type
            ),
            str("pool-match-order"),
            str("duplicate-clients-on-interface"),
            str("forward-snooped-clients").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),
            b(str("group"),
              dhcp_local_server_group
            )
        )
    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),
            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)
                )
            )
        )
      )
    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),
            a(str("service-profile"), arg),
            b(str("overrides"),
              dhcpv6_override_local_server_type
            ),
            b(str("group"),
              dhcpv6_local_server_group
            )
        )
    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),
            b(str("overrides"),
              dhcpv6_override_local_server_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)
                )
            )
        )
      )
    end

    rule(:dhcpv6_override_local_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)
        )
    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
            )
        )
    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("authentication"),
              jsscd_authentication_type
            ),
            b(str("group"),
              jsscd_group_type
            )
        )
    end

    rule(:jsscd_access_profile_type) do
        c(
            a(str("access-profile-name"), arg)
        )
    end

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

    rule(:jsscd_dynamic_profile_type) do
        c(
            a(str("dynamic-profile-name"), arg),
            b(str("aggregate-clients"),
                c(
                    c(
                      str("merge"),
                      str("replace")
                    )
                )
            )
        )
    end

    rule(:jsscd_group_type) do
      b(arg.as(:arg),
        c(
            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),
                c(
                    b(str("upto"),
                      interface_unit
                    ),
                    str("exclude")
                )
            ).as(:oneline)
        )
      )
    end

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

    rule(:juniper_multicast_snooping_options) do

    end

    rule(:juniper_next_hop_group_options) do
      b(arg.as(:arg),
        c(
            a(str("group-type"), arg),
            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(
            c(
              str("disable")
            ),
            b(str("file"),
                sca(
                    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_policy_options) do
        c(
            b(a(str("prefix-list"), arg),
                c(
                    prefix_list_items,
                    a(str("apply-path"), arg)
                )
            ),
            b(a(str("vsi-policy"), arg),
                c(
                    b(str("from"),
                        c(
                            b(str("vsi-manager"),
                                s(
                                  a(str("vsi-manager-id"), arg),
                                  a(str("vsi-type"), arg),
                                  a(str("vsi-version"), arg),
                                  a(str("vsi-instance"), arg)
                                )
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            a(str("filter"), arg)
                        )
                    )
                )
            ),
            b(a(str("policy-statement"), arg),
                c(
                    b(a(str("term"), arg),
                        c(
                            b(str("from"),
                                c(
                                    a(str("instance"), arg),
                                    a(str("family"), arg),
                                    a(str("protocol"), arg),
                                    a(str("rib"), arg),
                                    a(str("neighbor"), arg),
                                    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),
                                    a(str("origin"), arg),
                                    a(str("community"), arg),
                                    a(str("level"), arg),
                                    b(str("external"),
                                        c(
                                            a(str("type"), arg)
                                        )
                                    ),
                                    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
                                    ),
                                    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("multicast-scope"),
                                        c(
                                            c(
                                              str("node-local"),
                                              str("link-local"),
                                              str("site-local"),
                                              str("organization-local"),
                                              str("global"),
                                              a(str("scope_value"), arg)
                                            ),
                                            c(
                                              str("orhigher"),
                                              str("orlower")
                                            )
                                        )
                                    ).as(:oneline),
                                    str("aggregate-contributor"),
                                    a(str("state"), arg),
                                    a(str("route-type"), arg),
                                    a(str("next-hop-type"), arg),
                                    a(str("condition"), arg),
                                    b(str("community-count"),
                                      community_count_type
                                    )
                                )
                            ),
                            b(str("to"),
                                c(
                                    a(str("instance"), arg),
                                    a(str("family"), arg),
                                    a(str("protocol"), arg),
                                    a(str("rib"), arg),
                                    a(str("neighbor"), arg),
                                    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),
                                    a(str("origin"), arg),
                                    a(str("community"), arg),
                                    a(str("level"), arg),
                                    b(str("external"),
                                        c(
                                            a(str("type"), arg)
                                        )
                                    ),
                                    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
                                    )
                                )
                            ),
                            b(str("then"),
                                c(
                                    b(str("metric"),
                                        c(
                                            ca(
                                              a(str("add"), arg),
                                              a(str("subtract"), arg),
                                              b(str("igp"),
                                                  c(
                                                      a(str("metric_offset"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("minimum-igp"),
                                                  c(
                                                      a(str("metric_offset"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("expression"),
                                                metric_expression_type
                                              )
                                            )
                                        )
                                    ),
                                    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)
                                            )
                                        )
                                    ),
                                    a(str("priority"), arg),
                                    a(str("label-allocation"), arg),
                                    a(str("origin"), arg),
                                    b(str("aigp-originate"),
                                        c(
                                            a(str("distance"), arg)
                                        )
                                    ).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)
                                          ),
                                          a(str("community-name"), arg)
                                        )
                                    ).as(:oneline),
                                    a(str("damping"), arg),
                                    a(str("as-path-prepend"), quote | arg),
                                    b(str("as-path-expand"),
                                        c(
                                            c(
                                              b(str("last-as"),
                                                  c(
                                                      a(str("count"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("aspath"), arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("next-hop"),
                                        c(
                                            c(
                                              str("self"),
                                              str("peer-address"),
                                              ipaddr,
                                              str("reject"),
                                              str("discard"),
                                              a(str("next-table"), arg)
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("install-nexthop"),
                                        c(
                                            str("strict"),
                                            c(
                                              a(str("lsp"), arg),
                                              a(str("lsp-regex"), arg),
                                              a(str("static-lsp"), arg),
                                              a(str("static-lsp-regex"), arg)
                                            ),
                                            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)
                                                    )
                                                )
                                            )
                                        )
                                    ).as(:oneline),
                                    str("trace"),
                                    b(str("external"),
                                        c(
                                            a(str("type"), arg)
                                        )
                                    ),
                                    b(str("load-balance"),
                                        c(
                                            c(
                                              str("per-packet"),
                                              str("per-prefix")
                                            )
                                        )
                                    ).as(:oneline),
                                    str("no-route-localize"),
                                    str("install-to-fib"),
                                    str("no-install-to-fib"),
                                    a(str("class"), arg),
                                    a(str("destination-class"), arg),
                                    a(str("source-class"), arg),
                                    a(str("forwarding-class"), arg),
                                    b(str("map-to-interface"),
                                        c(
                                            c(
                                              str("self"),
                                              b(str("interface"),
                                                interface_name
                                              )
                                            )
                                        )
                                    ).as(:oneline),
                                    b(str("ssm-source"),
                                      ipaddr
                                    ),
                                    a(str("cos-next-hop-map"), arg),
                                    a(str("default-action"), arg),
                                    a(str("next"), arg),
                                    c(
                                      str("accept"),
                                      str("reject")
                                    )
                                )
                            )
                        )
                    ),
                    b(str("from"),
                        c(
                            a(str("instance"), arg),
                            a(str("family"), arg),
                            a(str("protocol"), arg),
                            a(str("rib"), arg),
                            a(str("neighbor"), arg),
                            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),
                            a(str("origin"), arg),
                            a(str("community"), arg),
                            a(str("level"), arg),
                            b(str("external"),
                                c(
                                    a(str("type"), arg)
                                )
                            ),
                            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
                            ),
                            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("multicast-scope"),
                                c(
                                    c(
                                      str("node-local"),
                                      str("link-local"),
                                      str("site-local"),
                                      str("organization-local"),
                                      str("global"),
                                      a(str("scope_value"), arg)
                                    ),
                                    c(
                                      str("orhigher"),
                                      str("orlower")
                                    )
                                )
                            ).as(:oneline),
                            str("aggregate-contributor"),
                            a(str("state"), arg),
                            a(str("route-type"), arg),
                            a(str("next-hop-type"), arg),
                            a(str("condition"), arg),
                            b(str("community-count"),
                              community_count_type
                            )
                        )
                    ),
                    b(str("to"),
                        c(
                            a(str("instance"), arg),
                            a(str("family"), arg),
                            a(str("protocol"), arg),
                            a(str("rib"), arg),
                            a(str("neighbor"), arg),
                            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),
                            a(str("origin"), arg),
                            a(str("community"), arg),
                            a(str("level"), arg),
                            b(str("external"),
                                c(
                                    a(str("type"), arg)
                                )
                            ),
                            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
                            )
                        )
                    ),
                    b(str("then"),
                        c(
                            b(str("metric"),
                                c(
                                    ca(
                                      a(str("add"), arg),
                                      a(str("subtract"), arg),
                                      b(str("igp"),
                                          c(
                                              a(str("metric_offset"), arg)
                                          )
                                      ).as(:oneline),
                                      b(str("minimum-igp"),
                                          c(
                                              a(str("metric_offset"), arg)
                                          )
                                      ).as(:oneline),
                                      b(str("expression"),
                                        metric_expression_type
                                      )
                                    )
                                )
                            ),
                            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)
                                    )
                                )
                            ),
                            a(str("priority"), arg),
                            a(str("label-allocation"), arg),
                            a(str("origin"), arg),
                            b(str("aigp-originate"),
                                c(
                                    a(str("distance"), arg)
                                )
                            ).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)
                                  ),
                                  a(str("community-name"), arg)
                                )
                            ).as(:oneline),
                            a(str("damping"), arg),
                            a(str("as-path-prepend"), quote | arg),
                            b(str("as-path-expand"),
                                c(
                                    c(
                                      b(str("last-as"),
                                          c(
                                              a(str("count"), arg)
                                          )
                                      ).as(:oneline),
                                      a(str("aspath"), arg)
                                    )
                                )
                            ).as(:oneline),
                            b(str("next-hop"),
                                c(
                                    c(
                                      str("self"),
                                      str("peer-address"),
                                      ipaddr,
                                      str("reject"),
                                      str("discard"),
                                      a(str("next-table"), arg)
                                    )
                                )
                            ).as(:oneline),
                            b(str("install-nexthop"),
                                c(
                                    str("strict"),
                                    c(
                                      a(str("lsp"), arg),
                                      a(str("lsp-regex"), arg),
                                      a(str("static-lsp"), arg),
                                      a(str("static-lsp-regex"), arg)
                                    ),
                                    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)
                                            )
                                        )
                                    )
                                )
                            ).as(:oneline),
                            str("trace"),
                            b(str("external"),
                                c(
                                    a(str("type"), arg)
                                )
                            ),
                            b(str("load-balance"),
                                c(
                                    c(
                                      str("per-packet"),
                                      str("per-prefix")
                                    )
                                )
                            ).as(:oneline),
                            str("no-route-localize"),
                            str("install-to-fib"),
                            str("no-install-to-fib"),
                            a(str("class"), arg),
                            a(str("destination-class"), arg),
                            a(str("source-class"), arg),
                            a(str("forwarding-class"), arg),
                            b(str("map-to-interface"),
                                c(
                                    c(
                                      str("self"),
                                      b(str("interface"),
                                        interface_name
                                      )
                                    )
                                )
                            ).as(:oneline),
                            b(str("ssm-source"),
                              ipaddr
                            ),
                            a(str("cos-next-hop-map"), arg),
                            a(str("default-action"), arg),
                            a(str("next"), arg),
                            c(
                              str("accept"),
                              str("reject")
                            )
                        )
                    )
                )
            ),
            b(a(str("community"), arg),
                c(
                    str("invert-match"),
                    a(str("members"), arg)
                )
            ),
            b(a(str("as-path"), arg),
              c(
                quote,
                arg
              )
            ),
            b(a(str("as-path-group"), arg),
                c(
                    b(a(str("as-path"), arg),
                      c(
                        quote,
                        arg
                      )
                    ).as(:oneline)
                )
            ),
            b(a(str("damping"), arg),
                c(
                    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(
                      a(str("route-active-on"), arg),
                      b(str("if-route-exists"),
                          c(
                              b(str("address"),
                                ipprefix
                              ),
                              a(str("table"), arg)
                          )
                      )
                    )
                )
            ),
            b(str("application-maps"),
              application_map_object
            )
        )
    end

    rule(:application_map_object) do
      b(arg.as(:arg),
        c(
            b(a(str("application"), arg),
                c(
                    a(str("code-points"), arg)
                )
            ).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(
          a(str("list_name"), 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"),
                          c(
                              a(str("metric_offset"), arg)
                          )
                      ).as(:oneline),
                      b(str("minimum-igp"),
                          c(
                              a(str("metric_offset"), arg)
                          )
                      ).as(:oneline),
                      b(str("expression"),
                        metric_expression_type
                      )
                    )
                )
            ),
            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)
                    )
                )
            ),
            a(str("priority"), arg),
            a(str("label-allocation"), arg),
            a(str("origin"), arg),
            b(str("aigp-originate"),
                c(
                    a(str("distance"), arg)
                )
            ).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)
                  ),
                  a(str("community-name"), arg)
                )
            ).as(:oneline),
            a(str("damping"), arg),
            a(str("as-path-prepend"), quote | arg),
            b(str("as-path-expand"),
                c(
                    c(
                      b(str("last-as"),
                          c(
                              a(str("count"), arg)
                          )
                      ).as(:oneline),
                      a(str("aspath"), arg)
                    )
                )
            ).as(:oneline),
            b(str("next-hop"),
                c(
                    c(
                      str("self"),
                      str("peer-address"),
                      ipaddr,
                      str("reject"),
                      str("discard"),
                      a(str("next-table"), arg)
                    )
                )
            ).as(:oneline),
            b(str("install-nexthop"),
                c(
                    str("strict"),
                    c(
                      a(str("lsp"), arg),
                      a(str("lsp-regex"), arg),
                      a(str("static-lsp"), arg),
                      a(str("static-lsp-regex"), arg)
                    ),
                    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)
                            )
                        )
                    )
                )
            ).as(:oneline),
            str("trace"),
            b(str("external"),
                c(
                    a(str("type"), arg)
                )
            ),
            b(str("load-balance"),
                c(
                    c(
                      str("per-packet"),
                      str("per-prefix")
                    )
                )
            ).as(:oneline),
            str("no-route-localize"),
            str("install-to-fib"),
            str("no-install-to-fib"),
            a(str("class"), arg),
            a(str("destination-class"), arg),
            a(str("source-class"), arg),
            a(str("forwarding-class"), arg),
            b(str("map-to-interface"),
                c(
                    c(
                      str("self"),
                      b(str("interface"),
                        interface_name
                      )
                    )
                )
            ).as(:oneline),
            b(str("ssm-source"),
              ipaddr
            ),
            a(str("cos-next-hop-map"), arg),
            a(str("default-action"), arg),
            a(str("next"), arg),
            c(
              str("accept"),
              str("reject")
            )
          )
        )
    end

    rule(:control_prefix_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("metric"),
                c(
                    ca(
                      a(str("add"), arg),
                      a(str("subtract"), arg),
                      b(str("igp"),
                          c(
                              a(str("metric_offset"), arg)
                          )
                      ).as(:oneline),
                      b(str("minimum-igp"),
                          c(
                              a(str("metric_offset"), arg)
                          )
                      ).as(:oneline),
                      b(str("expression"),
                        metric_expression_type
                      )
                    )
                )
            ),
            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)
                    )
                )
            ),
            a(str("priority"), arg),
            a(str("label-allocation"), arg),
            a(str("origin"), arg),
            b(str("aigp-originate"),
                c(
                    a(str("distance"), arg)
                )
            ).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)
                  ),
                  a(str("community-name"), arg)
                )
            ).as(:oneline),
            a(str("damping"), arg),
            a(str("as-path-prepend"), quote | arg),
            b(str("as-path-expand"),
                c(
                    c(
                      b(str("last-as"),
                          c(
                              a(str("count"), arg)
                          )
                      ).as(:oneline),
                      a(str("aspath"), arg)
                    )
                )
            ).as(:oneline),
            b(str("next-hop"),
                c(
                    c(
                      str("self"),
                      str("peer-address"),
                      ipaddr,
                      str("reject"),
                      str("discard"),
                      a(str("next-table"), arg)
                    )
                )
            ).as(:oneline),
            b(str("install-nexthop"),
                c(
                    str("strict"),
                    c(
                      a(str("lsp"), arg),
                      a(str("lsp-regex"), arg),
                      a(str("static-lsp"), arg),
                      a(str("static-lsp-regex"), arg)
                    ),
                    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)
                            )
                        )
                    )
                )
            ).as(:oneline),
            str("trace"),
            b(str("external"),
                c(
                    a(str("type"), arg)
                )
            ),
            b(str("load-balance"),
                c(
                    c(
                      str("per-packet"),
                      str("per-prefix")
                    )
                )
            ).as(:oneline),
            str("no-route-localize"),
            str("install-to-fib"),
            str("no-install-to-fib"),
            a(str("class"), arg),
            a(str("destination-class"), arg),
            a(str("source-class"), arg),
            a(str("forwarding-class"), arg),
            b(str("map-to-interface"),
                c(
                    c(
                      str("self"),
                      b(str("interface"),
                        interface_name
                      )
                    )
                )
            ).as(:oneline),
            b(str("ssm-source"),
              ipaddr
            ),
            a(str("cos-next-hop-map"), arg),
            a(str("default-action"), arg),
            a(str("next"), arg),
            c(
              str("accept"),
              str("reject")
            )
          )
        )
    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"),
                          c(
                              a(str("metric_offset"), arg)
                          )
                      ).as(:oneline),
                      b(str("minimum-igp"),
                          c(
                              a(str("metric_offset"), arg)
                          )
                      ).as(:oneline),
                      b(str("expression"),
                        metric_expression_type
                      )
                    )
                )
            ),
            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)
                    )
                )
            ),
            a(str("priority"), arg),
            a(str("label-allocation"), arg),
            a(str("origin"), arg),
            b(str("aigp-originate"),
                c(
                    a(str("distance"), arg)
                )
            ).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)
                  ),
                  a(str("community-name"), arg)
                )
            ).as(:oneline),
            a(str("damping"), arg),
            a(str("as-path-prepend"), quote | arg),
            b(str("as-path-expand"),
                c(
                    c(
                      b(str("last-as"),
                          c(
                              a(str("count"), arg)
                          )
                      ).as(:oneline),
                      a(str("aspath"), arg)
                    )
                )
            ).as(:oneline),
            b(str("next-hop"),
                c(
                    c(
                      str("self"),
                      str("peer-address"),
                      ipaddr,
                      str("reject"),
                      str("discard"),
                      a(str("next-table"), arg)
                    )
                )
            ).as(:oneline),
            b(str("install-nexthop"),
                c(
                    str("strict"),
                    c(
                      a(str("lsp"), arg),
                      a(str("lsp-regex"), arg),
                      a(str("static-lsp"), arg),
                      a(str("static-lsp-regex"), arg)
                    ),
                    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)
                            )
                        )
                    )
                )
            ).as(:oneline),
            str("trace"),
            b(str("external"),
                c(
                    a(str("type"), arg)
                )
            ),
            b(str("load-balance"),
                c(
                    c(
                      str("per-packet"),
                      str("per-prefix")
                    )
                )
            ).as(:oneline),
            str("no-route-localize"),
            str("install-to-fib"),
            str("no-install-to-fib"),
            a(str("class"), arg),
            a(str("destination-class"), arg),
            a(str("source-class"), arg),
            a(str("forwarding-class"), arg),
            b(str("map-to-interface"),
                c(
                    c(
                      str("self"),
                      b(str("interface"),
                        interface_name
                      )
                    )
                )
            ).as(:oneline),
            b(str("ssm-source"),
              ipaddr
            ),
            a(str("cos-next-hop-map"), arg),
            a(str("default-action"), arg),
            a(str("next"), arg),
            c(
              str("accept"),
              str("reject")
            )
          )
        )
    end

    rule(:juniper_port_mirror_options) do
        c(
            b(str("traceoptions"),
              sampling_traceoptions_type
            ),
            str("disable"),
            str("disable-all-instances"),
            str("mirror-once"),
            b(str("input"),
              pm_family_input_type
            ),
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            b(str("output"),
                              inet_pm_family_output_type
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                            b(str("output"),
                              inet6_pm_family_output_type
                            )
                        )
                    ),
                    str("any"),
                    b(str("vpls"),
                        c(
                            b(str("output"),
                              layer2_pm_family_output_type
                            )
                        )
                    ),
                    b(str("ccc"),
                        c(
                            b(str("output"),
                              layer2_pm_family_output_type
                            )
                        )
                    )
                )
            ),
            str("instance")
        )
    end

    rule(:inet6_pm_family_output_type) do
        c(
            c(
              b(str("interface"),
                inet6_pm_intf_type
              )
            ),
            str("no-filter-check")
        )
    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_pm_family_output_type) do
        c(
            c(
              b(str("interface"),
                inet_pm_intf_type
              ),
              a(str("next-hop-group"), arg)
            ),
            str("no-filter-check")
        )
    end

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

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

    rule(:juniper_protocols) do
        c(
            b(str("l2iw"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), str("error") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                c(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("igmp"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), 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"),
                                c(
                                    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 | str("interface-name"),
                        c(
                            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),
                            b(str("passive"),
                                c(
                                    str("allow-receive"),
                                    str("send-general-query"),
                                    str("send-group-query")
                                )
                            ).as(:oneline),
                            b(str("oif-map"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            b(str("mld"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), 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"),
                                c(
                                    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 | str("interface-name"),
                        c(
                            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),
                            str("accounting"),
                            str("no-accounting"),
                            b(str("passive"),
                                c(
                                    str("allow-receive"),
                                    str("send-general-query"),
                                    str("send-group-query")
                                )
                            ).as(:oneline),
                            b(str("oif-map"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            b(str("amt"),
              juniper_protocols_amt
            ),
            b(str("router-discovery"),
              juniper_protocols_router_discovery
            ),
            b(str("router-advertisement"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all")).as(:oneline)
                        )
                    ),
                    a(str("interface"), arg | str("interface-name"),
                        c(
                            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"),
                            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),
                            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("sap"),
                c(
                    c(
                      str("disable")
                    ),
                    b(a(str("listen"), arg),
                        c(
                            a(str("port"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("rsvp"),
                c(
                    c(
                      str("disable")
                    ),
                    b(str("graceful-restart"),
                        c(
                            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"),
                    str("hello-acknowledgements"),
                    b(str("node-hello"),
                        c(
                            a(str("hello-interval"), arg)
                        )
                    ).as(:oneline),
                    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"),
                              trace_file_type
                            ),
                            a(str("flag"), 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("all"),
                                c(
                                    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"),
                    b(str("preemption"),
                        c(
                            c(
                              str("disabled"),
                              str("normal"),
                              str("aggressive")
                            ),
                            b(str("soft-preemption"),
                                c(
                                    a(str("cleanup-timer"), arg)
                                )
                            )
                        )
                    ),
                    b(a(str("interface"), arg),
                        c(
                            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),
                            a(str("update-threshold"), arg),
                            b(str("link-protection"),
                                c(
                                    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"),
                                    a(str("priority"), a(arg, arg)).as(:oneline),
                                    b(a(str("path"), arg),
                                        c(
                                            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
                                            ),
                                            a(str("description"), quote | arg),
                                            a(str("priority"), a(arg, arg)).as(:oneline),
                                            a(str("class-of-service"), arg),
                                            a(str("hop-limit"), arg),
                                            str("no-cspf"),
                                            str("exclude-srlg"),
                                            b(a(str("path"), arg),
                                                c(
                                                    c(
                                                      str("loose"),
                                                      str("strict")
                                                    )
                                                )
                                            ).as(:oneline),
                                            b(str("admin-group"),
                                              admin_group_include_exclude
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("peer-interface"), arg),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("authentication-key"),
                              unreadable
                            ),
                            str("aggregate"),
                            str("no-aggregate"),
                            str("reliable"),
                            str("no-reliable"),
                            a(str("hello-interval"), arg)
                        )
                    ),
                    b(a(str("lsp-set"), arg),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("match-criteria"),
                              lsp_set_match_type
                            ),
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), 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("all"),
                                        c(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("mpls"),
              juniper_protocols_mpls
            ),
            b(str("bgp"),
              juniper_protocols_bgp
            ),
            b(str("bfd"),
              juniper_protocols_bfd
            ),
            b(str("dvmrp"),
                c(
                    c(
                      str("disable")
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), 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"),
                                c(
                                    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(
                            c(
                              str("disable")
                            ),
                            a(str("mode"), arg),
                            a(str("metric"), arg),
                            a(str("hold-time"), arg)
                        )
                    )
                )
            ),
            b(str("isis"),
              juniper_protocols_isis
            ),
            b(str("esis"),
              juniper_protocols_esis
            ),
            b(str("msdp"),
              juniper_protocols_msdp
            ),
            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(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), 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("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                        c(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            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(
                                            str("disable"),
                                            str("no-install"),
                                            str("downstream-paths-only")
                                        )
                                    ),
                                    a(str("prefix-export-limit"), 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(
                                    str("disable"),
                                    str("no-install"),
                                    str("downstream-paths-only")
                                )
                            ),
                            a(str("prefix-export-limit"), arg),
                            a(str("rib-group"), arg),
                            b(str("overload"),
                                c(
                                    a(str("timeout"), arg)
                                )
                            ),
                            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(
                                    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("traffic-engineering"),
                                c(
                                    str("no-topology"),
                                    str("multicast-rpf-routes"),
                                    str("ignore-lsp-metrics"),
                                    b(str("shortcuts"),
                                        c(
                                            str("lsp-metric-into-summary")
                                        )
                                    ),
                                    str("advertise-unnumbered-interfaces"),
                                    str("credibility-protocol-preference")
                                )
                            ),
                            a(str("route-type-community"), arg),
                            b(str("domain-id"),
                                c(
                                    c(
                                      a(str("domain-id"), arg),
                                      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),
                            b(str("export"),
                              policy_algebra
                            ),
                            b(str("import"),
                              policy_algebra
                            ),
                            a(str("reference-bandwidth"), arg),
                            str("no-rfc-1583"),
                            c(
                              str("no-nssa-abr")
                            ),
                            b(str("sham-link"),
                                c(
                                    b(str("local"),
                                      ipaddr
                                    )
                                )
                            ),
                            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")
                                                  )
                                              ),
                                              str("summaries"),
                                              str("no-summaries"),
                                              b(a(str("area-range"), arg),
                                                  c(
                                                      str("restrict"),
                                                      str("exact"),
                                                      b(str("override-metric"),
                                                          c(
                                                              a(str("metric"), arg),
                                                              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("virtual-link"),
                                        s(
                                          a(str("neighbor-id"), arg),
                                          a(str("transit-area"), arg),
                                          c(
                                            c(
                                              str("disable")
                                            ),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              )
                                            ),
                                            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),
                                                                c(
                                                                    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),
                                                                c(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("interface"), arg),
                                        c(
                                            c(
                                              str("disable")
                                            ),
                                            a(str("interface-type"), arg),
                                            c(
                                              str("link-protection"),
                                              str("node-link-protection")
                                            ),
                                            str("no-eligible-backup"),
                                            b(str("passive"),
                                                c(
                                                    b(str("traffic-engineering"),
                                                        c(
                                                            b(str("remote-node-id"),
                                                              ipaddr
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            str("secondary"),
                                            str("own-router-lsa"),
                                            b(str("bandwidth-based-metrics"),
                                                c(
                                                    b(a(str("bandwidth"), arg),
                                                        c(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("metric"), arg),
                                            a(str("te-metric"), arg),
                                            a(str("priority"), arg),
                                            b(str("ldp-synchronization"),
                                              ldp_sync_obj
                                            ),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              )
                                            ),
                                            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),
                                                                c(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    a(str("version"), arg),
                                                    a(str("minimum-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),
                                                            a(str("algorithm"), arg),
                                                            str("loose-check")
                                                        )
                                                    ),
                                                    str("full-neighbors-only")
                                                )
                                            ),
                                            str("dynamic-neighbors"),
                                            b(a(str("neighbor"), arg),
                                                c(
                                                    str("eligible")
                                                )
                                            ).as(:oneline),
                                            a(str("poll-interval"), arg),
                                            str("no-interface-state-traps")
                                        )
                                    ),
                                    str("no-context-identifier-advertisement"),
                                    a(str("context-identifier"), arg),
                                    b(a(str("label-switched-path"), arg),
                                        c(
                                            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),
                                                                c(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("peer-interface"), arg),
                                        c(
                                            c(
                                              str("disable")
                                            ),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              )
                                            ),
                                            str("demand-circuit"),
                                            str("flood-reduction"),
                                            str("no-neighbor-down-notification")
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    c(
                      str("disable")
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), 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("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                c(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    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(
                                    str("disable"),
                                    str("no-install"),
                                    str("downstream-paths-only")
                                )
                            ),
                            a(str("prefix-export-limit"), 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(
                            str("disable"),
                            str("no-install"),
                            str("downstream-paths-only")
                        )
                    ),
                    a(str("prefix-export-limit"), arg),
                    a(str("rib-group"), arg),
                    b(str("overload"),
                        c(
                            a(str("timeout"), arg)
                        )
                    ),
                    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(
                            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("traffic-engineering"),
                        c(
                            str("no-topology"),
                            str("multicast-rpf-routes"),
                            str("ignore-lsp-metrics"),
                            b(str("shortcuts"),
                                c(
                                    str("lsp-metric-into-summary")
                                )
                            ),
                            str("advertise-unnumbered-interfaces"),
                            str("credibility-protocol-preference")
                        )
                    ),
                    a(str("route-type-community"), arg),
                    b(str("domain-id"),
                        c(
                            c(
                              a(str("domain-id"), arg),
                              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),
                    b(str("export"),
                      policy_algebra
                    ),
                    b(str("import"),
                      policy_algebra
                    ),
                    a(str("reference-bandwidth"), arg),
                    str("no-rfc-1583"),
                    c(
                      str("no-nssa-abr")
                    ),
                    b(str("sham-link"),
                        c(
                            b(str("local"),
                              ipaddr
                            )
                        )
                    ),
                    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")
                                          )
                                      ),
                                      str("summaries"),
                                      str("no-summaries"),
                                      b(a(str("area-range"), arg),
                                          c(
                                              str("restrict"),
                                              str("exact"),
                                              b(str("override-metric"),
                                                  c(
                                                      a(str("metric"), arg),
                                                      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("virtual-link"),
                                s(
                                  a(str("neighbor-id"), arg),
                                  a(str("transit-area"), arg),
                                  c(
                                    c(
                                      str("disable")
                                    ),
                                    a(str("retransmit-interval"), arg),
                                    a(str("transit-delay"), arg),
                                    a(str("hello-interval"), arg),
                                    a(str("dead-interval"), arg),
                                    c(
                                      b(str("authentication"),
                                        juniper_ospf_authentication
                                      )
                                    ),
                                    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),
                                                        c(
                                                            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),
                                                        c(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("interface"), arg),
                                c(
                                    c(
                                      str("disable")
                                    ),
                                    a(str("interface-type"), arg),
                                    c(
                                      str("link-protection"),
                                      str("node-link-protection")
                                    ),
                                    str("no-eligible-backup"),
                                    b(str("passive"),
                                        c(
                                            b(str("traffic-engineering"),
                                                c(
                                                    b(str("remote-node-id"),
                                                      ipaddr
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    str("secondary"),
                                    str("own-router-lsa"),
                                    b(str("bandwidth-based-metrics"),
                                        c(
                                            b(a(str("bandwidth"), arg),
                                                c(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    a(str("metric"), arg),
                                    a(str("te-metric"), arg),
                                    a(str("priority"), arg),
                                    b(str("ldp-synchronization"),
                                      ldp_sync_obj
                                    ),
                                    a(str("retransmit-interval"), arg),
                                    a(str("transit-delay"), arg),
                                    a(str("hello-interval"), arg),
                                    a(str("dead-interval"), arg),
                                    c(
                                      b(str("authentication"),
                                        juniper_ospf_authentication
                                      )
                                    ),
                                    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),
                                                        c(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    ),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            a(str("version"), arg),
                                            a(str("minimum-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),
                                                    a(str("algorithm"), arg),
                                                    str("loose-check")
                                                )
                                            ),
                                            str("full-neighbors-only")
                                        )
                                    ),
                                    str("dynamic-neighbors"),
                                    b(a(str("neighbor"), arg),
                                        c(
                                            str("eligible")
                                        )
                                    ).as(:oneline),
                                    a(str("poll-interval"), arg),
                                    str("no-interface-state-traps")
                                )
                            ),
                            str("no-context-identifier-advertisement"),
                            a(str("context-identifier"), arg),
                            b(a(str("label-switched-path"), arg),
                                c(
                                    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),
                                                        c(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            b(a(str("peer-interface"), arg),
                                c(
                                    c(
                                      str("disable")
                                    ),
                                    a(str("retransmit-interval"), arg),
                                    a(str("transit-delay"), arg),
                                    a(str("hello-interval"), arg),
                                    a(str("dead-interval"), arg),
                                    c(
                                      b(str("authentication"),
                                        juniper_ospf_authentication
                                      )
                                    ),
                                    str("demand-circuit"),
                                    str("flood-reduction"),
                                    str("no-neighbor-down-notification")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("ldp"),
              juniper_protocols_ldp
            ),
            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(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"),
                                sca(
                                    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"), 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"),
                    str("delegate-processing"),
                    str("skew-timer-disable"),
                    a(str("global-advertisements-thrshold"), arg)
                )
            ),
            b(str("l2circuit"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), str("error") | str("topology") | str("fec") | str("connections") | str("oam") | str("egress-protection") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                c(
                                    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"),
                                    a(str("community"), arg),
                                    a(str("mtu"), arg),
                                    a(str("encapsulation-type"), arg),
                                    str("ignore-encapsulation-mismatch"),
                                    str("ignore-mtu-mismatch"),
                                    str("no-revert"),
                                    b(str("bandwidth"),
                                      bandwidth_type
                                    ),
                                    str("pseudowire-status-tlv"),
                                    a(str("switchover-delay"), arg),
                                    a(str("revert-time"), arg),
                                    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("oam"),
                                    b(str("egress-protection"),
                                        c(
                                            c(
                                              b(str("protector-interface"),
                                                interface_name
                                              ),
                                              b(str("protector-pe"),
                                                  c(
                                                      b(str("address"),
                                                        ipv4addr
                                                      ),
                                                      b(str("context-identifier"),
                                                        ipv4addr
                                                      ),
                                                      a(str("lsp"), arg)
                                                  )
                                              ).as(:oneline)
                                            ),
                                            b(str("protected-l2circuit"),
                                                c(
                                                    a(str("l2circuit-name"), 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
                                    ),
                                    b(str("end-interface"),
                                        c(
                                            b(str("interface"),
                                              interface_name
                                            ),
                                            str("no-revert"),
                                            b(str("protect-interface"),
                                              interface_name
                                            )
                                        )
                                    ),
                                    a(str("description"), quote | arg),
                                    a(str("encapsulation-type"), arg),
                                    str("ignore-encapsulation-mismatch"),
                                    str("ignore-mtu-mismatch")
                                )
                            )
                        )
                    )
                )
            ),
            b(str("link-management"),
              juniper_protocols_lmp
            ),
            b(str("pgm"),
              juniper_protocols_pgm
            ),
            b(str("bfd"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sca(
                                    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"), str("adjacency") | str("event") | str("error") | str("packet") | str("ppm-packet") | str("pipe") | str("pipe-detail") | str("state") | str("timer") | str("nsr-synchronization") | str("nsr-packet") | str("issu") | str("all")).as(:oneline)
                        )
                    ),
                    str("no-issu-timer-negotiation")
                )
            ),
            str("vpls"),
            b(str("neighbor-discovery"),
                c(
                    str("onlink-subnet-only"),
                    str("no-dad-on-state-change"),
                    str("secure")
                )
            ),
            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"),
                                sca(
                                    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"), 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"),
                                sca(
                                    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"), 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"),
                                sca(
                                    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"), str("configuration") | str("routing-socket") | str("process") | str("startup") | str("protocol") | str("packet") | str("ppm") | str("mc-ae") | str("all")).as(:oneline)
                        )
                    ),
                    a(str("ppm"), arg)
                )
            ),
            b(str("oam"),
                c(
                    b(str("ethernet"),
                        c(
                            b(str("link-fault-management"),
                                c(
                                    b(str("traceoptions"),
                                        c(
                                            str("no-remote-trace"),
                                            b(str("file"),
                                                sca(
                                                    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"), 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),
                                            a(str("link-discovery"), arg),
                                            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(
                                    str("performance-monitoring"),
                                    str("connection-protection"),
                                    b(str("traceoptions"),
                                      cfm_traceoptions
                                    ),
                                    b(a(str("action-profile"), arg),
                                        c(
                                            b(str("event"),
                                                c(
                                                    str("adjacency-loss"),
                                                    str("rdi"),
                                                    a(str("connection-protection-tlv"), arg)
                                                )
                                            ),
                                            b(str("action"),
                                                c(
                                                    str("interface-down"),
                                                    str("propagate-remote-mac-flush")
                                                )
                                            ),
                                            b(str("clear-action"),
                                                c(
                                                    b(str("interface-down"),
                                                        c(
                                                            str("peer-interface")
                                                        )
                                                    ).as(:oneline),
                                                    str("propagate-remote-mac-flush")
                                                )
                                            ),
                                            b(str("default-actions"),
                                                c(
                                                    str("interface-down")
                                                )
                                            )
                                        )
                                    ),
                                    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),
                                            a(str("age"), arg)
                                        )
                                    ),
                                    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") | str("md-name"),
                                        c(
                                            b(a(str("bridge-domain"), arg),
                                                c(
                                                    a(str("vlan-id"), arg)
                                                )
                                            ).as(:oneline),
                                            b(a(str("virtual-switch"), arg),
                                                c(
                                                    b(a(str("bridge-domain"), arg),
                                                        c(
                                                            a(str("vlan-id"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("instance"), arg).as(:oneline),
                                            a(str("interface"), arg).as(:oneline),
                                            a(str("level"), arg),
                                            a(str("name-format"), arg),
                                            a(str("mip-half-function"), arg),
                                            b(a(str("maintenance-association"), arg),
                                                c(
                                                    a(str("short-name-format"), arg),
                                                    str("protect-maintenance-association").as(:oneline),
                                                    a(str("primary-vid"), arg),
                                                    b(str("continuity-check"),
                                                        c(
                                                            a(str("interval"), arg),
                                                            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")
                                                        )
                                                    ),
                                                    a(str("mip-half-function"), arg),
                                                    b(a(str("mep"), arg),
                                                        c(
                                                            b(str("interface"),
                                                                c(
                                                                    b(str("interface-name"),
                                                                      interface_unit
                                                                    ),
                                                                    a(str("vlan"), arg),
                                                                    c(
                                                                      str("working"),
                                                                      str("protect")
                                                                    ),
                                                                    a(str("vlan-id"), arg)
                                                                )
                                                            ).as(:oneline),
                                                            a(str("direction"), arg),
                                                            a(str("priority"), arg),
                                                            str("auto-discovery"),
                                                            b(a(str("remote-mep"), arg),
                                                                c(
                                                                    a(str("action-profile"), arg),
                                                                    b(a(str("sla-iterator-profile"), arg),
                                                                        c(
                                                                            a(str("iteration-count"), arg),
                                                                            a(str("priority"), arg),
                                                                            a(str("data-tlv-size"), arg)
                                                                        )
                                                                    )
                                                                )
                                                            ),
                                                            a(str("lowest-priority-defect"), arg)
                                                        )
                                                    ),
                                                    b(str("policer"),
                                                        c(
                                                            a(str("continuity-check"), arg),
                                                            a(str("other"), arg),
                                                            a(str("all"), arg)
                                                        )
                                                    )
                                                )
                                            ),
                                            a(str("vlan-name"), arg)
                                        )
                                    ),
                                    b(str("esp-traceoptions"),
                                        c(
                                            b(str("file"),
                                              esp_trace_file_type
                                            ),
                                            a(str("flag"), str("krt") | str("error") | str("esp") | str("normal") | str("task") | str("lib") | str("timer") | str("interface") | str("all"),
                                                c(
                                                    str("disable")
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(a(str("evcs"), arg),
                                c(
                                    b(str("evc-protocol"),
                                        c(
                                            c(
                                              b(str("cfm"),
                                                  c(
                                                      a(str("maintenance-domain"), arg),
                                                      a(str("maintenance-association"), arg)
                                                  )
                                              ).as(:oneline),
                                              b(str("vpls"),
                                                  c(
                                                      a(str("routing-instance"), arg)
                                                  )
                                              ).as(:oneline)
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("remote-uni-count"), arg),
                                    str("multipoint-to-multipoint")
                                )
                            ),
                            b(str("lmi"),
                                c(
                                    b(str("traceoptions"),
                                        c(
                                            str("no-remote-trace"),
                                            b(str("file"),
                                                sca(
                                                    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"), 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),
                                            a(str("evc-map-type"), arg),
                                            b(a(str("evc"), arg),
                                                c(
                                                    str("default-evc"),
                                                    a(str("vlan-list"), arg)
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    str("gre-tunnel")
                )
            ),
            b(str("ppp-service"),
                c(
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sca(
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable"),
                                    b(str("match"),
                                      regular_expression
                                    )
                                )
                            ).as(:oneline),
                            a(str("level"), arg),
                            a(str("flag"), 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("l2-learning"),
              juniper_protocols_bridge
            ),
            b(str("ppp"),
                c(
                    b(str("traceoptions"),
                      ppp_traceoptions_type
                    ),
                    b(str("monitor-session"),
                        s(
                          b(str("session-name"),
                                (str("all") | arg)
                          )
                        )
                    )
                )
            ),
            b(str("pppoe"),
                c(
                    b(str("traceoptions"),
                      pppoe_traceoptions_type
                    ),
                    str("pado-advertise"),
                    str("service-name-tables")
                )
            ),
            b(str("r2cp"),
                c(
                    c(
                      str("disable")
                    ),
                    b(str("traceoptions"),
                      r2cp_traceoptions_type
                    ),
                    a(str("server-port"), arg),
                    b(str("client-port"),
                        c(
                            c(
                              a(str("port-number"), arg),
                              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("virtual-channel-group"), arg),
                            a(str("radio-interface"), arg)
                        )
                    )
                )
            ),
            b(str("dcbx"),
              c(
                str("disable"),
                a(str("interface"), str("all") | arg,
                  c(
                    a(str("application-map"), arg),
                    b(str("applications"),
                      b(str("fcoe"),
                        str("no-auto-negotiation")
                      )
                    ),
                    str("disable"),
                    b(str("priority-flow-control"),
                      str("no-auto-negotiation")
                    )
                  )
                )
              )
            ),

            b(str("lldp"),
                c(
                    c(
                      str("disable")
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              esp_trace_file_type
                            ),
                            a(str("flag"), str("all") | str("configuration") | str("rtsock") | str("packet") | str("interface") | str("vlan") | str("snmp") | str("netbios"),
                                c(
                                    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),
                    str("netbios-snooping"),
                    a(str("interface"), arg | str("all"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    )
                )
            ),
            b(str("lldp-med"),
                c(
                    c(
                      str("disable")
                    ),
                    a(str("fast-start"), arg),
                    a(str("interface"), arg | str("all"),
                        c(
                            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("dot1x"),
              juniper_protocols_dot1x
            ),
            b(str("gvrp"),
                c(
                    c(
                      str("disable")
                    ),
                    a(str("join-timer"), arg),
                    a(str("leave-timer"), arg),
                    a(str("leaveall-timer"), arg),
                    a(str("interface"), str("all") | arg,
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              esp_trace_file_type
                            ),
                            a(str("flag"), str("event") | str("receive") | str("transmit") | str("eswd") | str("error") | str("state") | str("all"),
                                c(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("mvrp"),
                c(
                    c(
                      str("disable")
                    ),
                    str("no-dynamic-vlan"),
                    str("add-attribute-length-in-pdu"),
                    a(str("interface"), str("all") | arg,
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("join-timer"), arg),
                            a(str("leave-timer"), arg),
                            a(str("leaveall-timer"), arg),
                            a(str("registration"), arg)
                        )
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              esp_trace_file_type
                            ),
                            a(str("flag"), str("eswd") | str("event") | str("receive") | str("transmit") | str("error") | str("timer") | str("all"),
                                c(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("protection-group"),
              juniper_protocols_protection_group
            ),
            b(str("stp"),
              juniper_protocols_stp
            ),
            b(str("rstp"),
              juniper_protocols_stp
            ),
            b(str("mstp"),
              juniper_protocols_mstp
            ),
            b(str("vstp"),
              juniper_protocols_vstp
            ),
            str("edge-virtual-bridging"),
            b(str("igmp-snooping"),
              juniper_protocols_igmp_snooping
            ),
            b(str("mld-snooping"),
              juniper_protocols_mld_snooping
            ),
            b(str("layer2-control"),
              juniper_protocols_layer2_control
            ),
            b(str("sflow"),
              juniper_protocols_sflow
            )
        )
    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(:co_ordinate_elements) do
        c(
            a(str("longitude"), arg),
            a(str("lattitude"), arg)
        )
    end

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

    rule(:juniper_protocols_amt) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), str("packets") | str("errors") | str("tunnels") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            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),
            str("accounting")
        )
    end

    rule(:juniper_protocols_bd) do
        c(
            b(str("mac-table-size"),
                c(
                    a(str("limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            b(str("interface-mac-limit"),
                c(
                    a(str("limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("mac-statistics"),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        c(
                            a(str("limit"), arg),
                            a(str("packet-action"), arg)
                        )
                    ),
                    a(str("remote-site-id"), arg),
                    b(a(str("static-mac"), arg),
                        c(
                            a(str("vlan-id"), arg)
                        )
                    ),
                    str("no-mac-learning"),
                    a(str("description"), quote | arg)
                )
            )
        )
    end

    rule(:juniper_protocols_bgp) do
        c(
            c(
              str("disable")
            ),
            str("precision-timers"),
            str("no-precision-timers"),
            b(str("path-selection"),
                c(
                    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")
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), 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("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            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"),
                c(
                    ca(
                      b(str("minimum-igp"),
                          c(
                              a(str("metric-offset"), arg)
                          )
                      ).as(:oneline),
                      b(str("igp"),
                          c(
                              a(str("metric-offset"), arg),
                              str("delay-med-update")
                          )
                      ).as(:oneline)
                    )
                )
            ).as(:oneline),
            b(str("multihop"),
                c(
                    a(str("ttl"), arg),
                    str("no-nexthop-change")
                )
            ),
            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("hold-time"), arg),
            str("passive"),
            str("advertise-inactive"),
            str("advertise-peer-as"),
            str("no-advertise-peer-as"),
            b(str("advertise-external"),
                c(
                    str("conditional")
                )
            ).as(:oneline),
            a(str("keep"), arg),
            str("no-aggregator-id"),
            str("mtu-discovery"),
            a(str("out-delay"), arg),
            str("log-updown"),
            str("damping"),
            b(str("import"),
              policy_algebra
            ),
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            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("labeled-unicast"),
                              bgp_afi_labeled
                            )
                        )
                    ),
                    b(str("inet-vpn"),
                        c(
                            b(str("unicast"),
                              bgp_afi_vpn
                            ),
                            b(str("multicast"),
                              bgp_afi_vpn
                            ),
                            b(str("flow"),
                              bgp_afi_default
                            ),
                            b(str("any"),
                              bgp_afi_vpn
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                            b(str("unicast"),
                              bgp_afi_topo
                            ),
                            b(str("multicast"),
                              bgp_afi_default
                            ),
                            b(str("any"),
                              bgp_afi_default
                            ),
                            b(str("labeled-unicast"),
                              bgp_afi_inet6_labeled
                            )
                        )
                    ),
                    b(str("inet6-vpn"),
                        c(
                            b(str("unicast"),
                              bgp_afi_vpn
                            ),
                            b(str("multicast"),
                              bgp_afi_vpn
                            ),
                            b(str("any"),
                              bgp_afi_vpn
                            )
                        )
                    ),
                    b(str("iso-vpn"),
                        c(
                            b(str("unicast"),
                              bgp_afi_vpn
                            )
                        )
                    ),
                    b(str("l2vpn"),
                        c(
                            b(str("auto-discovery-only"),
                              bgp_afi_default
                            ),
                            b(str("signaling"),
                              bgp_afi_l2vpn
                            )
                        )
                    ),
                    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("route-target"),
                        c(
                            b(str("prefix-limit"),
                              bgpaf_prefix_limit
                            ),
                            b(str("accepted-prefix-limit"),
                              bgpaf_accepted_prefix_limit
                            ),
                            a(str("external-paths"), arg),
                            str("advertise-default")
                        )
                    ),
                    str("bridge-vpn"),
                    str("fabric-vpn")
                )
            ),
            a(str("authentication-key"), arg),
            a(str("authentication-algorithm"), arg),
            a(str("authentication-key-chain"), arg),
            b(str("export"),
              policy_algebra
            ),
            str("vpn-apply-export"),
            b(str("remove-private"),
                c(
                    b(str("all"),
                        c(
                            b(str("replace"),
                                c(
                                    str("nearest")
                                )
                            ).as(:oneline)
                        )
                    ).as(:oneline)
                )
            ).as(:oneline),
            b(str("cluster"),
              areaid
            ),
            str("no-client-reflect"),
            a(str("peer-as"), arg),
            b(str("local-as"),
                ca(
                    a(str("loops"), arg),
                    str("private"),
                    str("alias"),
                    str("no-prepend-global-as")
                )
            ).as(:oneline),
            a(str("ipsec-sa"), arg),
            str("unconfigured-peer-graceful-restart"),
            b(str("graceful-restart"),
                c(
                    c(
                      str("disable")
                    ),
                    a(str("restart-time"), arg),
                    a(str("stale-routes-time"), arg)
                )
            ),
            str("include-mp-next-hop"),
            b(str("idle-after-switch-over"),
                c(
                    c(
                      str("forever"),
                      a(str("timeout"), arg)
                    )
                )
            ).as(:oneline),
            b(str("outbound-route-filter"),
                c(
                    str("bgp-orf-cisco-mode"),
                    b(str("prefix-based"),
                        c(
                            b(str("accept"),
                                c(
                                    str("inet"),
                                    str("inet6")
                                )
                            )
                        )
                    )
                )
            ),
            a(str("tcp-mss"), arg),
            b(str("bfd-liveness-detection"),
                c(
                    a(str("version"), arg),
                    a(str("minimum-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),
                            a(str("algorithm"), arg),
                            str("loose-check")
                        )
                    ),
                    a(str("session-mode"), arg),
                    a(str("holddown-interval"), arg)
                )
            ),
            b(a(str("group"), arg),
                c(
                    a(str("type"), arg),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), 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("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                c(
                                    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"),
                        c(
                            ca(
                              b(str("minimum-igp"),
                                  c(
                                      a(str("metric-offset"), arg)
                                  )
                              ).as(:oneline),
                              b(str("igp"),
                                  c(
                                      a(str("metric-offset"), arg),
                                      str("delay-med-update")
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("multihop"),
                        c(
                            a(str("ttl"), arg),
                            str("no-nexthop-change")
                        )
                    ),
                    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("hold-time"), arg),
                    str("passive"),
                    str("advertise-inactive"),
                    str("advertise-peer-as"),
                    str("no-advertise-peer-as"),
                    b(str("advertise-external"),
                        c(
                            str("conditional")
                        )
                    ).as(:oneline),
                    a(str("keep"), arg),
                    str("no-aggregator-id"),
                    str("mtu-discovery"),
                    a(str("out-delay"), arg),
                    str("log-updown"),
                    str("damping"),
                    b(str("import"),
                      policy_algebra
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    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("labeled-unicast"),
                                      bgp_afi_labeled
                                    )
                                )
                            ),
                            b(str("inet-vpn"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_vpn
                                    ),
                                    b(str("multicast"),
                                      bgp_afi_vpn
                                    ),
                                    b(str("flow"),
                                      bgp_afi_default
                                    ),
                                    b(str("any"),
                                      bgp_afi_vpn
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_topo
                                    ),
                                    b(str("multicast"),
                                      bgp_afi_default
                                    ),
                                    b(str("any"),
                                      bgp_afi_default
                                    ),
                                    b(str("labeled-unicast"),
                                      bgp_afi_inet6_labeled
                                    )
                                )
                            ),
                            b(str("inet6-vpn"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_vpn
                                    ),
                                    b(str("multicast"),
                                      bgp_afi_vpn
                                    ),
                                    b(str("any"),
                                      bgp_afi_vpn
                                    )
                                )
                            ),
                            b(str("iso-vpn"),
                                c(
                                    b(str("unicast"),
                                      bgp_afi_vpn
                                    )
                                )
                            ),
                            b(str("l2vpn"),
                                c(
                                    b(str("auto-discovery-only"),
                                      bgp_afi_default
                                    ),
                                    b(str("signaling"),
                                      bgp_afi_l2vpn
                                    )
                                )
                            ),
                            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("route-target"),
                                c(
                                    b(str("prefix-limit"),
                                      bgpaf_prefix_limit
                                    ),
                                    b(str("accepted-prefix-limit"),
                                      bgpaf_accepted_prefix_limit
                                    ),
                                    a(str("external-paths"), arg),
                                    str("advertise-default")
                                )
                            ),
                            str("bridge-vpn"),
                            str("fabric-vpn")
                        )
                    ),
                    a(str("authentication-key"), arg),
                    a(str("authentication-algorithm"), arg),
                    a(str("authentication-key-chain"), arg),
                    b(str("export"),
                      policy_algebra
                    ),
                    str("vpn-apply-export"),
                    b(str("remove-private"),
                        c(
                            b(str("all"),
                                c(
                                    b(str("replace"),
                                        c(
                                            str("nearest")
                                        )
                                    ).as(:oneline)
                                )
                            ).as(:oneline)
                        )
                    ).as(:oneline),
                    b(str("cluster"),
                      areaid
                    ),
                    str("no-client-reflect"),
                    a(str("peer-as"), arg),
                    b(str("local-as"),
                        ca(
                            a(str("loops"), arg),
                            str("private"),
                            str("alias"),
                            str("no-prepend-global-as")
                        )
                    ).as(:oneline),
                    a(str("ipsec-sa"), arg),
                    str("unconfigured-peer-graceful-restart"),
                    b(str("graceful-restart"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("restart-time"), arg),
                            a(str("stale-routes-time"), arg)
                        )
                    ),
                    str("include-mp-next-hop"),
                    b(str("idle-after-switch-over"),
                        c(
                            c(
                              str("forever"),
                              a(str("timeout"), arg)
                            )
                        )
                    ).as(:oneline),
                    b(str("outbound-route-filter"),
                        c(
                            str("bgp-orf-cisco-mode"),
                            b(str("prefix-based"),
                                c(
                                    b(str("accept"),
                                        c(
                                            str("inet"),
                                            str("inet6")
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("tcp-mss"), arg),
                    b(str("bfd-liveness-detection"),
                        c(
                            a(str("version"), arg),
                            a(str("minimum-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),
                                    a(str("algorithm"), arg),
                                    str("loose-check")
                                )
                            ),
                            a(str("session-mode"), arg),
                            a(str("holddown-interval"), arg)
                        )
                    ),
                    b(str("multipath"),
                        c(
                            str("multiple-as")
                        )
                    ).as(:oneline),
                    str("as-override"),
                    b(str("allow"),
                      ipprefix
                    ),
                    str("mvpn-iana-rt-import"),
                    b(a(str("neighbor"), arg),
                        c(
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), 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("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                        c(
                                            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"),
                                c(
                                    ca(
                                      b(str("minimum-igp"),
                                          c(
                                              a(str("metric-offset"), arg)
                                          )
                                      ).as(:oneline),
                                      b(str("igp"),
                                          c(
                                              a(str("metric-offset"), arg),
                                              str("delay-med-update")
                                          )
                                      ).as(:oneline)
                                    )
                                )
                            ).as(:oneline),
                            b(str("multihop"),
                                c(
                                    a(str("ttl"), arg),
                                    str("no-nexthop-change")
                                )
                            ),
                            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("hold-time"), arg),
                            str("passive"),
                            str("advertise-inactive"),
                            str("advertise-peer-as"),
                            str("no-advertise-peer-as"),
                            b(str("advertise-external"),
                                c(
                                    str("conditional")
                                )
                            ).as(:oneline),
                            a(str("keep"), arg),
                            str("no-aggregator-id"),
                            str("mtu-discovery"),
                            a(str("out-delay"), arg),
                            str("log-updown"),
                            str("damping"),
                            b(str("import"),
                              policy_algebra
                            ),
                            b(str("family"),
                                c(
                                    b(str("inet"),
                                        c(
                                            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("labeled-unicast"),
                                              bgp_afi_labeled
                                            )
                                        )
                                    ),
                                    b(str("inet-vpn"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_vpn
                                            ),
                                            b(str("multicast"),
                                              bgp_afi_vpn
                                            ),
                                            b(str("flow"),
                                              bgp_afi_default
                                            ),
                                            b(str("any"),
                                              bgp_afi_vpn
                                            )
                                        )
                                    ),
                                    b(str("inet6"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_topo
                                            ),
                                            b(str("multicast"),
                                              bgp_afi_default
                                            ),
                                            b(str("any"),
                                              bgp_afi_default
                                            ),
                                            b(str("labeled-unicast"),
                                              bgp_afi_inet6_labeled
                                            )
                                        )
                                    ),
                                    b(str("inet6-vpn"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_vpn
                                            ),
                                            b(str("multicast"),
                                              bgp_afi_vpn
                                            ),
                                            b(str("any"),
                                              bgp_afi_vpn
                                            )
                                        )
                                    ),
                                    b(str("iso-vpn"),
                                        c(
                                            b(str("unicast"),
                                              bgp_afi_vpn
                                            )
                                        )
                                    ),
                                    b(str("l2vpn"),
                                        c(
                                            b(str("auto-discovery-only"),
                                              bgp_afi_default
                                            ),
                                            b(str("signaling"),
                                              bgp_afi_l2vpn
                                            )
                                        )
                                    ),
                                    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("route-target"),
                                        c(
                                            b(str("prefix-limit"),
                                              bgpaf_prefix_limit
                                            ),
                                            b(str("accepted-prefix-limit"),
                                              bgpaf_accepted_prefix_limit
                                            ),
                                            a(str("external-paths"), arg),
                                            str("advertise-default")
                                        )
                                    ),
                                    str("bridge-vpn"),
                                    str("fabric-vpn")
                                )
                            ),
                            a(str("authentication-key"), arg),
                            a(str("authentication-algorithm"), arg),
                            a(str("authentication-key-chain"), arg),
                            b(str("export"),
                              policy_algebra
                            ),
                            str("vpn-apply-export"),
                            b(str("remove-private"),
                                c(
                                    b(str("all"),
                                        c(
                                            b(str("replace"),
                                                c(
                                                    str("nearest")
                                                )
                                            ).as(:oneline)
                                        )
                                    ).as(:oneline)
                                )
                            ).as(:oneline),
                            b(str("cluster"),
                              areaid
                            ),
                            str("no-client-reflect"),
                            a(str("peer-as"), arg),
                            b(str("local-as"),
                                ca(
                                    a(str("loops"), arg),
                                    str("private"),
                                    str("alias"),
                                    str("no-prepend-global-as")
                                )
                            ).as(:oneline),
                            a(str("ipsec-sa"), arg),
                            str("unconfigured-peer-graceful-restart"),
                            b(str("graceful-restart"),
                                c(
                                    c(
                                      str("disable")
                                    ),
                                    a(str("restart-time"), arg),
                                    a(str("stale-routes-time"), arg)
                                )
                            ),
                            str("include-mp-next-hop"),
                            b(str("idle-after-switch-over"),
                                c(
                                    c(
                                      str("forever"),
                                      a(str("timeout"), arg)
                                    )
                                )
                            ).as(:oneline),
                            b(str("outbound-route-filter"),
                                c(
                                    str("bgp-orf-cisco-mode"),
                                    b(str("prefix-based"),
                                        c(
                                            b(str("accept"),
                                                c(
                                                    str("inet"),
                                                    str("inet6")
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            a(str("tcp-mss"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    a(str("version"), arg),
                                    a(str("minimum-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),
                                            a(str("algorithm"), arg),
                                            str("loose-check")
                                        )
                                    ),
                                    a(str("session-mode"), arg),
                                    a(str("holddown-interval"), arg)
                                )
                            ),
                            b(str("multipath"),
                                c(
                                    str("multiple-as")
                                )
                            ).as(:oneline),
                            str("as-override")
                        )
                    )
                )
            ),
            a(str("drop-path-attributes"), arg)
        )
    end

    rule(:juniper_protocols_bfd) do
      b(str("traceoptions"),
        c(
          b(str("file"),
            trace_file_type
          ),
          a(str("flag"), str("adjacency") | str("all") | str("error") | str("event") | str("issu") | str("nsr-packet") | str("nsr-synchronization") | str("packet") | str("pipe") | str("pipe-detail") | str("ppm-packet") | str("state") | str("timer"),
            str("disable")
          )
        )
      )
    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
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline)
        )
    end

    rule(:apath_options) do
        c(
            str("receive"),
            b(str("send"),
                c(
                    b(str("prefix-policy"),
                      policy_algebra
                    ),
                    a(str("path-count"), arg)
                )
            )
        )
    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
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("no-validate"),
              policy_algebra
            )
        )
    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
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("aggregate-label"),
                c(
                    a(str("community"), arg)
                )
            ),
            str("per-group-label"),
            b(str("traffic-statistics"),
              bgpaf_traffic_statistics
            ),
            str("explicit-null").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
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline)
        )
    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
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            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("inet.3")
                )
            ),
            b(str("explicit-null"),
                c(
                    str("connected-only")
                )
            ).as(:oneline),
            str("resolve-vpn")
        )
    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
            ),
            b(str("loops"),
              bgpaf_loops
            ).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
            ),
            b(str("loops"),
              bgpaf_loops
            ).as(:oneline),
            b(str("aggregate-label"),
                c(
                    a(str("community"), arg)
                )
            )
        )
    end

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

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

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

    rule(:bgpaf_loops) do
        c(
            a(str("loops"), arg)
        ).as(:oneline)
    end

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

    rule(:bgpaf_traffic_statistics) do
        c(
            b(str("file"),
              trace_file_type
            ),
            a(str("interval"), arg)
        )
    end

    rule(:juniper_protocols_bridge) do
        c(
            a(str("global-mac-table-aging-time"), arg),
            a(str("global-le-aging-time"), arg),
            a(str("global-le-bridge-domain-aging-time"), arg),
            b(str("global-mac-limit"),
                c(
                    a(str("mac-limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            str("global-mac-statistics"),
            str("global-no-mac-learning")
        )
    end

    rule(:juniper_protocols_dot1x) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      esp_trace_file_type
                    ),
                    a(str("flag"), 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"),
                        c(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("authenticator"),
                c(
                    a(str("authentication-profile-name"), arg),
                    str("no-mac-table-binding"),
                    b(a(str("static"), arg),
                        c(
                            a(str("vlan-assignment"), arg),
                            b(str("interface"),
                              interface_name
                            )
                        )
                    ),
                    a(str("interface"), str("all") | arg,
                        c(
                            str("disable"),
                            a(str("supplicant"), arg),
                            a(str("retries"), arg),
                            a(str("quiet-period"), arg),
                            a(str("transmit-period"), arg),
                            b(str("mac-radius"),
                                c(
                                    str("restrict"),
                                    str("flap-on-disconnect")
                                )
                            ),
                            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("guest-vlan"), arg),
                            b(str("server-reject-vlan"),
                                c(
                                    a(str("vlan-name"), arg),
                                    a(str("block-interval"), arg),
                                    str("eapol-block")
                                )
                            ).as(:oneline),
                            str("lldp-med-bypass"),
                            b(str("server-fail"),
                                c(
                                    c(
                                      str("deny"),
                                      str("permit"),
                                      a(str("vlan-name"), arg),
                                      str("use-cache")
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_esis) do
        c(
            c(
              str("disable")
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), 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"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("preference"), arg),
            b(str("graceful-restart"),
                c(
                    c(
                      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),
                    c(
                      str("disable")
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_igmp_snooping) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      esp_trace_file_type
                    ),
                    a(str("flag"), str("packets") | str("query") | str("report") | str("leave") | str("vlan") | str("nexthop") | str("krt") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("vlan"), str("all") | arg,
                c(
                    str("disable"),
                    a(str("version"), arg),
                    a(str("query-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    str("no-default-flooding"),
                    b(str("proxy"),
                        c(
                            b(str("source-address"),
                              ipv4addr
                            )
                        )
                    ),
                    b(str("data-forwarding"),
                        c(
                            c(
                              b(str("source"),
                                  c(
                                      b(str("groups"),
                                        ipv4prefix
                                      )
                                  )
                              ),
                              b(str("receiver"),
                                  c(
                                      a(str("source-vlans"), arg),
                                      str("install")
                                  )
                              )
                            )
                        )
                    ),
                    a(str("interface"), str("all") | str("interface-name"),
                        c(
                            b(str("static"),
                                c(
                                    a(str("group"), arg)
                                )
                            ),
                            str("multicast-router-interface")
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_isis) do
        c(
            c(
              str("disable")
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), str("error") | str("spf") | str("packets") | str("hello") | str("lsp") | str("psn") | str("csn") | str("lsp-generation") | str("graceful-restart") | str("ldp-synchronization") | str("nsr-synchronization") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("export"),
              policy_algebra
            ),
            a(str("reference-bandwidth"), arg),
            a(str("lsp-lifetime"), arg),
            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("no-adjacency-holddown"),
            str("ignore-attached-bit"),
            b(str("rib-group"),
              rib_group_type
            ),
            b(str("spf-options"),
                c(
                    a(str("delay"), arg),
                    a(str("holddown"), arg),
                    a(str("rapid-runs"), arg)
                )
            ),
            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")
                )
            ),
            b(str("traffic-engineering"),
                c(
                    c(
                      str("disable")
                    ),
                    str("credibility-protocol-preference"),
                    str("ignore-lsp-metrics"),
                    a(str("family"), str("inet") | str("inet6"),
                        c(
                            b(str("shortcuts"),
                                c(
                                    str("multicast-rpf-routes")
                                )
                            )
                        )
                    ),
                    b(str("multipath"),
                        c(
                            str("lsp-equal-cost")
                        )
                    )
                )
            ),
            b(str("graceful-restart"),
                c(
                    c(
                      str("disable")
                    ),
                    str("helper-disable"),
                    a(str("restart-duration"), arg)
                )
            ).as(:oneline),
            b(a(str("level"), arg),
                c(
                    c(
                      str("disable")
                    ),
                    b(str("authentication-key"),
                      unreadable
                    ),
                    a(str("authentication-type"), arg),
                    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)
                )
            ),
            b(a(str("interface"), arg),
                c(
                    c(
                      str("disable")
                    ),
                    a(str("hello-padding-type"), arg),
                    b(str("ldp-synchronization"),
                      ldp_sync_obj
                    ),
                    a(str("lsp-interval"), arg),
                    b(str("csnp-interval"),
                        c(
                            c(
                              a(str("csnp-interval-number"), arg),
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    b(str("mesh-group"),
                        c(
                            c(
                              a(str("mesh-group-number"), arg),
                              str("blocked")
                            )
                        )
                    ).as(:oneline),
                    str("point-to-point"),
                    c(
                      str("link-protection"),
                      str("node-link-protection")
                    ),
                    str("no-eligible-backup"),
                    str("passive"),
                    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(
                            a(str("version"), arg),
                            a(str("minimum-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),
                                    a(str("algorithm"), arg),
                                    str("loose-check")
                                )
                            )
                        )
                    ),
                    b(a(str("level"), arg),
                        c(
                            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("te-metric"), arg),
                            b(str("hello-authentication-key"),
                              unreadable
                            ),
                            a(str("hello-authentication-type"), arg),
                            a(str("hello-authentication-key-chain"), arg),
                            a(str("hello-interval"), arg),
                            a(str("hold-time"), arg),
                            a(str("priority"), arg),
                            str("passive")
                        )
                    )
                )
            ),
            b(a(str("label-switched-path"), arg),
                c(
                    b(a(str("level"), arg),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("metric"), arg)
                        )
                    )
                )
            ),
            b(a(str("context-identifier"), arg),
                c(
                    b(a(str("level"), arg),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_ldp) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), str("error") | str("event") | str("packets") | str("periodic") | str("initialization") | str("notification") | str("address") | str("label") | str("binding") | str("path") | str("ppmd") | str("nsr-synchronization") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable"),
                            b(str("filter"),
                              ldp_filter_obj
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("traffic-statistics"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("interval"), arg),
                    str("no-penultimate-hop")
                )
            ),
            b(str("graceful-restart"),
                c(
                    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)
                )
            ),
            a(str("preference"), arg),
            str("no-forwarding"),
            str("l2-smart-policy"),
            str("track-igp-metric"),
            str("strict-targeted-hellos"),
            b(str("import"),
              policy_algebra
            ),
            b(str("export"),
              policy_algebra
            ),
            b(str("egress-policy"),
              policy_algebra
            ),
            b(str("next-hop"),
                c(
                    b(str("merged"),
                        c(
                            b(str("policy"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            str("deaggregate"),
            str("no-deaggregate"),
            str("explicit-null"),
            a(str("label-withdrawal-delay"), arg),
            b(str("transport-address"),
                c(
                    c(
                      str("router-id"),
                      str("interface"),
                      b(str("address"),
                        ipaddr
                      )
                    )
                )
            ).as(:oneline),
            a(str("keepalive-interval"), arg),
            a(str("keepalive-timeout"), arg),
            b(a(str("interface"), arg),
                c(
                    c(
                      str("disable")
                    ),
                    a(str("hello-interval"), arg),
                    a(str("hold-time"), arg),
                    a(str("transport-address"), arg),
                    str("allow-subnet-mismatch"),
                    str("no-allow-subnet-mismatch")
                )
            ),
            b(a(str("session"), arg),
                c(
                    a(str("authentication-key"), arg),
                    a(str("authentication-algorithm"), arg),
                    a(str("authentication-key-chain"), arg)
                )
            ),
            b(str("session-protection"),
                c(
                    a(str("timeout"), arg)
                )
            ).as(:oneline),
            b(str("igp-synchronization"),
                c(
                    a(str("holddown-interval"), arg)
                )
            ),
            b(str("log-updown"),
                c(
                    b(str("trap"),
                        c(
                            c(
                              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("oam"),
                c(
                    b(str("ingress-policy"),
                      policy_algebra
                    ),
                    b(a(str("fec"), arg),
                        c(
                            c(
                              b(str("bfd-liveness-detection"),
                                  c(
                                      a(str("version"), arg),
                                      a(str("minimum-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"),
                                          c(
                                              c(
                                                str("remove-route"),
                                                str("remove-nexthop")
                                              )
                                          )
                                      ).as(:oneline),
                                      a(str("holddown-interval"), arg)
                                  )
                              ),
                              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("bfd-liveness-detection"),
                        c(
                            a(str("version"), arg),
                            a(str("minimum-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"),
                                c(
                                    c(
                                      str("remove-route"),
                                      str("remove-nexthop")
                                    )
                                )
                            ).as(:oneline),
                            a(str("holddown-interval"), arg)
                        )
                    ),
                    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("targeted-hello"),
                c(
                    a(str("hello-interval"), arg),
                    a(str("hold-time"), arg)
                )
            ),
            str("p2mp"),
            str("upstream-label-assignment")
        )
    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),
                    c(
                      str("disable")
                    ),
                    c(
                      b(a(str("interface"), arg),
                          c(
                              b(str("local-address"),
                                ipaddr
                              ),
                              b(str("remote-address"),
                                ipaddr
                              ),
                              a(str("remote-id"), arg),
                              c(
                                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),
                              c(
                                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"),
                      trace_file_type
                    ),
                    a(str("flag"), str("init") | str("show") | str("route-socket") | str("parse") | str("process") | str("server") | str("routing") | str("packets") | str("hello-packets") | str("state") | str("all")).as(:oneline)
                )
            )
        )
    end

    rule(:juniper_protocols_mld_snooping) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      esp_trace_file_type
                    ),
                    a(str("flag"), str("packets") | str("query") | str("report") | str("leave") | str("vlan") | str("nexthop") | str("krt") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("vlan"), str("all") | arg,
                c(
                    str("disable"),
                    a(str("version"), arg),
                    a(str("query-interval"), arg),
                    a(str("query-last-member-interval"), arg),
                    a(str("query-response-interval"), arg),
                    a(str("robust-count"), arg),
                    str("immediate-leave"),
                    a(str("interface"), str("all") | str("interface-name"),
                        c(
                            b(str("static"),
                                c(
                                    a(str("group"), arg)
                                )
                            ),
                            str("multicast-router-interface")
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_layer2_control) do
      c(
        b(str("bpdu-block"),
          c(
            a(str("disable-timeout"), arg),
            a(str("interface"), any)
          )
        ),
        b(str("mac-rewrite"),
          b(a(str("interface"), arg),
            c(
              str("enable-all-ifl"),
              b(str("protocol"),
                c(
                  str("cdp"),
                  str("stp"),
                  str("vtp"),
                  str("pvstp")
                )
              )
            )
          )
        ),
        str("nonstop-bridging"),
        b(str("traceoptions"),
          c(
            b(str("file"),
              sca(
                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"), str("all") | str("kernel") | str("change-events") | str("kernel-detail") | str("config-states") | str("resource-usage") | str("gres-events") | str("select-events"),
              c(
                str("disable")
              )
            ).as(:oneline)
          )
        )
      )
    end

    rule(:juniper_protocols_mobile_ipv4) do
        c(
            b(str("traceoptions"),
              mip_trace_options_type
            ),
            b(str("authenticate"),
                c(
                    a(str("order"), arg)
                )
            ),
            b(str("home-agent"),
              mip_home_agent_type
            ),
            b(str("peer"),
              mip_peer_type
            ),
            b(str("access-type"),
              mip_access_type
            ),
            b(str("dynamic-home-assignment"),
              dynamic_home_assignment_type
            )
        )
    end

    rule(:dynamic_home_assignment_type) do
        c(
            b(str("home-agent"),
                c(
                    b(a(str("nai"), arg),
                        c(
                            b(str("home-agent"),
                              ipv4addr
                            )
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_msdp) do
        c(
            a(str("data-encapsulation"), arg),
            b(str("rib-group"),
              rib_group_inet_type
            ),
            b(str("active-source-limit"),
                c(
                    a(str("maximum"), arg),
                    a(str("threshold"), 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"),
                      trace_file_type
                    ),
                    a(str("flag"), 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"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("peer"), arg),
                c(
                    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"),
                              trace_file_type
                            ),
                            a(str("flag"), 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"),
                                c(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("active-source-limit"),
                        c(
                            a(str("maximum"), arg),
                            a(str("threshold"), arg)
                        )
                    ),
                    str("default-peer"),
                    a(str("authentication-key"), arg)
                )
            ),
            b(a(str("source"), arg),
                c(
                    b(str("active-source-limit"),
                        c(
                            a(str("maximum"), arg),
                            a(str("threshold"), arg)
                        )
                    )
                )
            ),
            b(a(str("group"), arg),
                c(
                    a(str("mode"), 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"),
                              trace_file_type
                            ),
                            a(str("flag"), 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"),
                                c(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("peer"), arg),
                        c(
                            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"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), 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"),
                                        c(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            b(str("active-source-limit"),
                                c(
                                    a(str("maximum"), arg),
                                    a(str("threshold"), arg)
                                )
                            ),
                            str("default-peer"),
                            a(str("authentication-key"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:juniper_protocols_mstp) do
        c(
            c(
              str("disable")
            ),
            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("traceoptions"),
              stp_trace_options_esp
            ),
            a(str("bridge-priority"), arg),
            a(str("interface"), str("all") | arg,
                c(
                    a(str("priority"), arg),
                    a(str("cost"), arg),
                    str("disable"),
                    str("arp-on-stp"),
                    a(str("mode"), arg),
                    str("edge"),
                    b(str("bpdu-timeout-action"),
                        c(
                            str("block"),
                            str("log")
                        )
                    ),
                    str("no-root-port")
                )
            ),
            b(a(str("msti"), arg),
                c(
                    a(str("bridge-priority"), arg),
                    a(str("vlan"), arg),
                    b(a(str("interface"), arg),
                        c(
                            a(str("priority"), arg),
                            a(str("cost"), arg),
                            str("disable"),
                            str("arp-on-stp")
                        )
                    )
                )
            ),
            str("bpdu-block-on-edge")
        )
    end

    rule(:juniper_protocols_ospf) do
        c(
            c(
              str("disable")
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), 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("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            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(
                            str("disable"),
                            str("no-install"),
                            str("downstream-paths-only")
                        )
                    ),
                    a(str("prefix-export-limit"), 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(
                    str("disable"),
                    str("no-install"),
                    str("downstream-paths-only")
                )
            ),
            a(str("prefix-export-limit"), arg),
            a(str("rib-group"), arg),
            b(str("overload"),
                c(
                    a(str("timeout"), arg)
                )
            ),
            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(
                    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("traffic-engineering"),
                c(
                    str("no-topology"),
                    str("multicast-rpf-routes"),
                    str("ignore-lsp-metrics"),
                    b(str("shortcuts"),
                        c(
                            str("lsp-metric-into-summary")
                        )
                    ),
                    str("advertise-unnumbered-interfaces"),
                    str("credibility-protocol-preference")
                )
            ),
            a(str("route-type-community"), arg),
            b(str("domain-id"),
                c(
                    c(
                      a(str("domain-id"), arg),
                      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),
            b(str("export"),
              policy_algebra
            ),
            b(str("import"),
              policy_algebra
            ),
            a(str("reference-bandwidth"), arg),
            str("no-rfc-1583"),
            c(
              str("no-nssa-abr")
            ),
            b(str("sham-link"),
                c(
                    b(str("local"),
                      ipaddr
                    )
                )
            ),
            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")
                                  )
                              ),
                              str("summaries"),
                              str("no-summaries"),
                              b(a(str("area-range"), arg),
                                  c(
                                      str("restrict"),
                                      str("exact"),
                                      b(str("override-metric"),
                                          c(
                                              a(str("metric"), arg),
                                              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("virtual-link"),
                        s(
                          a(str("neighbor-id"), arg),
                          a(str("transit-area"), arg),
                          c(
                            c(
                              str("disable")
                            ),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              )
                            ),
                            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),
                                                c(
                                                    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),
                                                c(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("interface"), arg),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("interface-type"), arg),
                            c(
                              str("link-protection"),
                              str("node-link-protection")
                            ),
                            str("no-eligible-backup"),
                            b(str("passive"),
                                c(
                                    b(str("traffic-engineering"),
                                        c(
                                            b(str("remote-node-id"),
                                              ipaddr
                                            )
                                        )
                                    )
                                )
                            ),
                            str("secondary"),
                            str("own-router-lsa"),
                            b(str("bandwidth-based-metrics"),
                                c(
                                    b(a(str("bandwidth"), arg),
                                        c(
                                            a(str("metric"), arg)
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            a(str("metric"), arg),
                            a(str("te-metric"), arg),
                            a(str("priority"), arg),
                            b(str("ldp-synchronization"),
                              ldp_sync_obj
                            ),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              )
                            ),
                            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),
                                                c(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            ),
                            b(str("bfd-liveness-detection"),
                                c(
                                    a(str("version"), arg),
                                    a(str("minimum-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),
                                            a(str("algorithm"), arg),
                                            str("loose-check")
                                        )
                                    ),
                                    str("full-neighbors-only")
                                )
                            ),
                            str("dynamic-neighbors"),
                            b(a(str("neighbor"), arg),
                                c(
                                    str("eligible")
                                )
                            ).as(:oneline),
                            a(str("poll-interval"), arg),
                            str("no-interface-state-traps")
                        )
                    ),
                    str("no-context-identifier-advertisement"),
                    a(str("context-identifier"), arg),
                    b(a(str("label-switched-path"), arg),
                        c(
                            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),
                                                c(
                                                    a(str("metric"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(a(str("peer-interface"), arg),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("retransmit-interval"), arg),
                            a(str("transit-delay"), arg),
                            a(str("hello-interval"), arg),
                            a(str("dead-interval"), arg),
                            c(
                              b(str("authentication"),
                                juniper_ospf_authentication
                              )
                            ),
                            str("demand-circuit"),
                            str("flood-reduction"),
                            str("no-neighbor-down-notification")
                        )
                    )
                )
            )
        )
    end

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

    rule(:juniper_protocols_pim) do
        c(
            b(str("family"),
                c(
                    b(str("inet"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    )
                )
            ),
            c(
              str("disable")
            ),
            b(str("nonstop-routing"),
                c(
                    c(
                      str("disable")
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), 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("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable"),
                            b(str("filter"),
                              pim_filter_obj
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("dense-groups"),
              pim_dense_group_type
            ),
            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("rib-group"),
              rib_group_type
            ),
            b(str("import"),
              policy_algebra
            ),
            b(str("export"),
              policy_algebra
            ),
            a(str("assert-timeout"), arg),
            a(str("join-prune-timeout"), arg),
            b(str("spt-threshold"),
                c(
                    b(str("infinity"),
                      policy_algebra
                    )
                )
            ),
            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("rp-register-policy"),
                      policy_algebra
                    ),
                    b(str("dr-register-policy"),
                      policy_algebra
                    ),
                    b(str("local"),
                        c(
                            b(str("address"),
                              ipv4addr
                            ),
                            c(
                              str("disable")
                            ),
                            a(str("priority"), arg),
                            a(str("hold-time"), arg),
                            a(str("group-ranges"), arg),
                            str("override"),
                            b(str("family"),
                                c(
                                    b(str("inet"),
                                        c(
                                            b(str("address"),
                                              ipv4addr
                                            ),
                                            c(
                                              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
                                            ),
                                            c(
                                              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(
                            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")
                                )
                            )
                        )
                    ),
                    str("bidirectional")
                )
            ),
            b(a(str("interface"), arg),
                c(
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    c(
                                      str("disable")
                                    )
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    c(
                                      str("disable")
                                    )
                                )
                            )
                        )
                    ),
                    c(
                      str("disable")
                    ),
                    str("bidirectional"),
                    a(str("mode"), arg),
                    a(str("priority"), arg),
                    a(str("version"), arg),
                    a(str("hello-interval"), arg),
                    b(str("neighbor-policy"),
                      policy_algebra
                    ),
                    str("accept-remote-source"),
                    str("reset-tracking-bit"),
                    a(str("propagation-delay"), arg),
                    a(str("override-interval"), arg),
                    b(str("bfd-liveness-detection"),
                        c(
                            a(str("version"), arg),
                            a(str("minimum-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),
                                    a(str("algorithm"), arg),
                                    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(
                    c(
                      str("disable")
                    ),
                    a(str("restart-duration"), arg),
                    str("no-bidirectional-mode")
                )
            ),
            str("join-load-balance"),
            str("dr-election-on-p2p"),
            str("no-wildcard-register-stop"),
            a(str("nexthop-hold-time"), arg),
            str("mpls-internet-multicast"),
            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
                    )
                )
            )
        )
    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),
            b(str("ethernet-ring"),
              juniper_protocols_protection_group_ethernet_ring
            ),
            a(str("hold-interval"), arg)
        )
    end

    rule(:erp_trace_options) do
        c(
            b(str("file"),
              esp_trace_file_type
            ),
            a(str("flag"), str("config") | str("debug") | str("normal") | str("events") | str("pdu") | str("timers") | str("state-machine") | str("periodic-packet-management") | str("all")).as(:oneline)
        )
    end

    rule(:juniper_protocols_protection_group_eaps) do
        c(
            b(str("profile"),
              juniper_protocols_protection_group_eaps_profile
            )
        )
    end

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

    rule(:juniper_protocols_protection_group_ethernet_ring) do
      b(arg.as(:arg),
        c(
            b(str("node-id"),
              mac_unicaset
            ),
            str("ring-protection-link-owner"),
            a(str("restore-interval"), arg),
            a(str("guard-interval"), arg),
            a(str("hold-interval"), 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(
                    b(str("interface"),
                      interface_name
                    ),
                    a(str("vlan"), arg)
                )
            ),
            str("ring-protection-link-end"),
            str("interface-none")
        )
    end

    rule(:juniper_protocols_rip) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), 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"),
                        c(
                            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"),
                c(
                    c(
                      str("broadcast"),
                      str("multicast"),
                      str("none"),
                      str("version-1")
                    )
                )
            ).as(:oneline),
            b(str("receive"),
                c(
                    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),
            a(str("authentication-type"), arg),
            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(
                            a(str("version"), arg),
                            a(str("minimum-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),
                                    a(str("algorithm"), arg),
                                    str("loose-check")
                                )
                            )
                        )
                    ),
                    b(a(str("neighbor"), arg),
                        c(
                            a(str("route-timeout"), arg),
                            a(str("update-interval"), arg),
                            a(str("interface-type"), arg),
                            str("dynamic-peers"),
                            a(str("peer"), arg).as(:oneline),
                            a(str("metric-in"), arg),
                            b(str("send"),
                                c(
                                    c(
                                      str("broadcast"),
                                      str("multicast"),
                                      str("none"),
                                      str("version-1")
                                    )
                                )
                            ).as(:oneline),
                            b(str("receive"),
                                c(
                                    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
                            ),
                            a(str("authentication-type"), arg),
                            b(str("authentication-key"),
                              unreadable
                            ),
                            b(str("bfd-liveness-detection"),
                                c(
                                    a(str("version"), arg),
                                    a(str("minimum-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),
                                            a(str("algorithm"), arg),
                                            str("loose-check")
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("graceful-restart"),
                c(
                    c(
                      str("disable")
                    ),
                    a(str("restart-time"), arg)
                )
            )
        )
    end

    rule(:juniper_protocols_ripng) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), 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"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("metric-in"), arg),
            b(str("send"),
                c(
                    c(
                      str("none")
                    )
                )
            ).as(:oneline),
            b(str("receive"),
                c(
                    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"),
                                c(
                                    c(
                                      str("none")
                                    )
                                )
                            ).as(:oneline),
                            b(str("receive"),
                                c(
                                    c(
                                      str("none")
                                    )
                                )
                            ).as(:oneline),
                            b(str("import"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            b(str("graceful-restart"),
                c(
                    c(
                      str("disable")
                    ),
                    a(str("restart-time"), arg)
                )
            )
        )
    end

    rule(:juniper_protocols_router_discovery) do
        c(
            c(
              str("disable")
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), 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_stp) do
        c(
            c(
              str("disable")
            ),
            a(str("bridge-priority"), arg),
            a(str("max-age"), arg),
            a(str("hello-time"), arg),
            a(str("forward-delay"), arg),
            b(str("traceoptions"),
              stp_trace_options_esp
            ),
            a(str("interface"), str("all") | arg,
                c(
                    a(str("priority"), arg),
                    a(str("cost"), arg),
                    str("disable"),
                    str("arp-on-stp"),
                    a(str("mode"), arg),
                    str("edge"),
                    b(str("bpdu-timeout-action"),
                        c(
                            str("block"),
                            str("log")
                        )
                    ),
                    str("no-root-port")
                )
            ),
            str("bpdu-block-on-edge")
        )
    end

    rule(:juniper_protocols_vstp) do
        c(
            c(
              str("disable")
            ),
            a(str("force-version"), arg),
            str("bpdu-block-on-edge"),
            b(str("vlan-group"),
                c(
                    b(a(str("group"), arg),
                        c(
                            a(str("vlan"), arg),
                            a(str("bridge-priority"), arg),
                            a(str("max-age"), arg),
                            a(str("hello-time"), arg),
                            a(str("forward-delay"), arg),
                            b(str("traceoptions"),
                              stp_trace_options_esp
                            ),
                            a(str("interface"), str("all") | arg,
                                c(
                                    a(str("priority"), arg),
                                    a(str("cost"), arg),
                                    str("disable"),
                                    str("arp-on-stp"),
                                    a(str("mode"), arg),
                                    str("edge"),
                                    b(str("bpdu-timeout-action"),
                                        c(
                                            str("block"),
                                            str("log")
                                        )
                                    ),
                                    str("no-root-port")
                                )
                            )
                        )
                    )
                )
            ),
            a(str("vlan"), str("all") | arg,
                c(
                    a(str("bridge-priority"), arg),
                    a(str("max-age"), arg),
                    a(str("hello-time"), arg),
                    a(str("forward-delay"), arg),
                    b(str("traceoptions"),
                      stp_trace_options_esp
                    ),
                    a(str("interface"), str("all") | arg,
                        c(
                            a(str("priority"), arg),
                            a(str("cost"), arg),
                            str("disable"),
                            str("arp-on-stp"),
                            a(str("mode"), arg),
                            str("edge"),
                            b(str("bpdu-timeout-action"),
                                c(
                                    str("block"),
                                    str("log")
                                )
                            ),
                            str("no-root-port")
                        )
                    )
                )
            ),
            b(a(str("interface"), arg),
              c(
                a(str("priority"), arg),
                a(str("cost"), arg),
                a(str("mode"), str("p2p") | str("shared")),
                str("edge")
              )
            )
        )
    end

    rule(:juniper_routing_instance) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("vlan-model"), arg),
            a(str("instance-role"), arg),
            a(str("instance-type"), arg),
            c(
              str("no-vrf-propagate-ttl"),
              str("vrf-propagate-ttl")
            ),
            c(
              a(str("vlan-id"), arg),
              b(str("vlan-tags"),
                  c(
                      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("static-subscribers"),
                              jsscd_static_subscribers_type
                            )
                        )
                    )
                )
            ),
            b(str("services"),
                c(
                    b(str("mobile-ip"),
                      juniper_protocols_mobile_ipv4
                    )
                )
            ),
            b(str("access"),
                c(
                    b(str("address-assignment"),
                      address_assignment_type
                    ),
                    str("address-protection")
                )
            ),
            b(str("access-profile"),
                c(
                    a(str("access-profile-name"), arg)
                )
            ).as(:oneline),
            a(str("interface"), arg | str("interface-name"),
                c(
                    c(
                      str("any"),
                      str("unicast"),
                      str("multicast")
                    )
                )
            ),
            b(str("routing-interface"),
              interface_unit
            ),
            str("no-local-switching"),
            str("qualified-bum-pruning-mode"),
            str("no-irb-layer-2-copy"),
            b(str("route-distinguisher"),
                c(
                    a(str("rd-type"), arg)
                )
            ).as(:oneline),
            b(str("l2vpn-id"),
                c(
                    a(str("community"), 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("pim-ssm"),
                          c(
                              b(str("group-address"),
                                ipv4addr
                              )
                          )
                      )
                    ),
                    b(str("selective"),
                        c(
                            a(str("tunnel-limit"), 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("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(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(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("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("vrf-import"),
              policy_algebra
            ),
            b(str("vrf-export"),
              policy_algebra
            ),
            b(str("vrf-target"),
                ca(
                    a(str("import"), arg),
                    a(str("export"), arg)
                )
            ),
            str("no-vrf-advertise"),
            b(str("vrf-advertise-selective"),
                c(
                    b(str("family"),
                        c(
                            str("inet-mvpn"),
                            str("inet6-mvpn")
                        )
                    )
                )
            ),
            b(str("vrf-table-label"),
                c(
                    str("source-class-usage")
                )
            ).as(:oneline),
            b(str("routing-options"),
              juniper_routing_options
            ),
            b(str("forwarding-options"),
              juniper_forwarding_options
            ),
            b(str("multicast-snooping-options"),
              juniper_multicast_snooping_options
            ),
            b(str("protocols"),
                c(
                    b(str("bgp"),
                      juniper_protocols_bgp
                    ),
                    b(str("bfd"),
                      juniper_protocols_bfd
                    ),
                    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(
                                    c(
                                      str("disable")
                                    ),
                                    b(str("traceoptions"),
                                        c(
                                            b(str("file"),
                                              trace_file_type
                                            ),
                                            a(str("flag"), 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("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                                c(
                                                    str("send"),
                                                    str("receive"),
                                                    str("detail"),
                                                    str("disable")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    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(
                                                    str("disable"),
                                                    str("no-install"),
                                                    str("downstream-paths-only")
                                                )
                                            ),
                                            a(str("prefix-export-limit"), 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(
                                            str("disable"),
                                            str("no-install"),
                                            str("downstream-paths-only")
                                        )
                                    ),
                                    a(str("prefix-export-limit"), arg),
                                    a(str("rib-group"), arg),
                                    b(str("overload"),
                                        c(
                                            a(str("timeout"), arg)
                                        )
                                    ),
                                    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(
                                            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("traffic-engineering"),
                                        c(
                                            str("no-topology"),
                                            str("multicast-rpf-routes"),
                                            str("ignore-lsp-metrics"),
                                            b(str("shortcuts"),
                                                c(
                                                    str("lsp-metric-into-summary")
                                                )
                                            ),
                                            str("advertise-unnumbered-interfaces"),
                                            str("credibility-protocol-preference")
                                        )
                                    ),
                                    a(str("route-type-community"), arg),
                                    b(str("domain-id"),
                                        c(
                                            c(
                                              a(str("domain-id"), arg),
                                              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),
                                    b(str("export"),
                                      policy_algebra
                                    ),
                                    b(str("import"),
                                      policy_algebra
                                    ),
                                    a(str("reference-bandwidth"), arg),
                                    str("no-rfc-1583"),
                                    c(
                                      str("no-nssa-abr")
                                    ),
                                    b(str("sham-link"),
                                        c(
                                            b(str("local"),
                                              ipaddr
                                            )
                                        )
                                    ),
                                    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")
                                                          )
                                                      ),
                                                      str("summaries"),
                                                      str("no-summaries"),
                                                      b(a(str("area-range"), arg),
                                                          c(
                                                              str("restrict"),
                                                              str("exact"),
                                                              b(str("override-metric"),
                                                                  c(
                                                                      a(str("metric"), arg),
                                                                      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("virtual-link"),
                                                s(
                                                  a(str("neighbor-id"), arg),
                                                  a(str("transit-area"), arg),
                                                  c(
                                                    c(
                                                      str("disable")
                                                    ),
                                                    a(str("retransmit-interval"), arg),
                                                    a(str("transit-delay"), arg),
                                                    a(str("hello-interval"), arg),
                                                    a(str("dead-interval"), arg),
                                                    c(
                                                      b(str("authentication"),
                                                        juniper_ospf_authentication
                                                      )
                                                    ),
                                                    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),
                                                                        c(
                                                                            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),
                                                                        c(
                                                                            a(str("metric"), arg)
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(a(str("interface"), arg),
                                                c(
                                                    c(
                                                      str("disable")
                                                    ),
                                                    a(str("interface-type"), arg),
                                                    c(
                                                      str("link-protection"),
                                                      str("node-link-protection")
                                                    ),
                                                    str("no-eligible-backup"),
                                                    b(str("passive"),
                                                        c(
                                                            b(str("traffic-engineering"),
                                                                c(
                                                                    b(str("remote-node-id"),
                                                                      ipaddr
                                                                    )
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    str("secondary"),
                                                    str("own-router-lsa"),
                                                    b(str("bandwidth-based-metrics"),
                                                        c(
                                                            b(a(str("bandwidth"), arg),
                                                                c(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    ),
                                                    a(str("metric"), arg),
                                                    a(str("te-metric"), arg),
                                                    a(str("priority"), arg),
                                                    b(str("ldp-synchronization"),
                                                      ldp_sync_obj
                                                    ),
                                                    a(str("retransmit-interval"), arg),
                                                    a(str("transit-delay"), arg),
                                                    a(str("hello-interval"), arg),
                                                    a(str("dead-interval"), arg),
                                                    c(
                                                      b(str("authentication"),
                                                        juniper_ospf_authentication
                                                      )
                                                    ),
                                                    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),
                                                                        c(
                                                                            a(str("metric"), arg)
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            )
                                                        )
                                                    ),
                                                    b(str("bfd-liveness-detection"),
                                                        c(
                                                            a(str("version"), arg),
                                                            a(str("minimum-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),
                                                                    a(str("algorithm"), arg),
                                                                    str("loose-check")
                                                                )
                                                            ),
                                                            str("full-neighbors-only")
                                                        )
                                                    ),
                                                    str("dynamic-neighbors"),
                                                    b(a(str("neighbor"), arg),
                                                        c(
                                                            str("eligible")
                                                        )
                                                    ).as(:oneline),
                                                    a(str("poll-interval"), arg),
                                                    str("no-interface-state-traps")
                                                )
                                            ),
                                            str("no-context-identifier-advertisement"),
                                            a(str("context-identifier"), arg),
                                            b(a(str("label-switched-path"), arg),
                                                c(
                                                    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),
                                                                        c(
                                                                            a(str("metric"), arg)
                                                                        )
                                                                    ).as(:oneline)
                                                                )
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            b(a(str("peer-interface"), arg),
                                                c(
                                                    c(
                                                      str("disable")
                                                    ),
                                                    a(str("retransmit-interval"), arg),
                                                    a(str("transit-delay"), arg),
                                                    a(str("hello-interval"), arg),
                                                    a(str("dead-interval"), arg),
                                                    c(
                                                      b(str("authentication"),
                                                        juniper_ospf_authentication
                                                      )
                                                    ),
                                                    str("demand-circuit"),
                                                    str("flood-reduction"),
                                                    str("no-neighbor-down-notification")
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                                c(
                                    b(str("file"),
                                      trace_file_type
                                    ),
                                    a(str("flag"), 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("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                        c(
                                            str("send"),
                                            str("receive"),
                                            str("detail"),
                                            str("disable")
                                        )
                                    ).as(:oneline)
                                )
                            ),
                            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(
                                            str("disable"),
                                            str("no-install"),
                                            str("downstream-paths-only")
                                        )
                                    ),
                                    a(str("prefix-export-limit"), 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(
                                    str("disable"),
                                    str("no-install"),
                                    str("downstream-paths-only")
                                )
                            ),
                            a(str("prefix-export-limit"), arg),
                            a(str("rib-group"), arg),
                            b(str("overload"),
                                c(
                                    a(str("timeout"), arg)
                                )
                            ),
                            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(
                                    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("traffic-engineering"),
                                c(
                                    str("no-topology"),
                                    str("multicast-rpf-routes"),
                                    str("ignore-lsp-metrics"),
                                    b(str("shortcuts"),
                                        c(
                                            str("lsp-metric-into-summary")
                                        )
                                    ),
                                    str("advertise-unnumbered-interfaces"),
                                    str("credibility-protocol-preference")
                                )
                            ),
                            a(str("route-type-community"), arg),
                            b(str("domain-id"),
                                c(
                                    c(
                                      a(str("domain-id"), arg),
                                      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),
                            b(str("export"),
                              policy_algebra
                            ),
                            b(str("import"),
                              policy_algebra
                            ),
                            a(str("reference-bandwidth"), arg),
                            str("no-rfc-1583"),
                            c(
                              str("no-nssa-abr")
                            ),
                            b(str("sham-link"),
                                c(
                                    b(str("local"),
                                      ipaddr
                                    )
                                )
                            ),
                            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")
                                                  )
                                              ),
                                              str("summaries"),
                                              str("no-summaries"),
                                              b(a(str("area-range"), arg),
                                                  c(
                                                      str("restrict"),
                                                      str("exact"),
                                                      b(str("override-metric"),
                                                          c(
                                                              a(str("metric"), arg),
                                                              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("virtual-link"),
                                        s(
                                          a(str("neighbor-id"), arg),
                                          a(str("transit-area"), arg),
                                          c(
                                            c(
                                              str("disable")
                                            ),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              )
                                            ),
                                            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),
                                                                c(
                                                                    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),
                                                                c(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("interface"), arg),
                                        c(
                                            c(
                                              str("disable")
                                            ),
                                            a(str("interface-type"), arg),
                                            c(
                                              str("link-protection"),
                                              str("node-link-protection")
                                            ),
                                            str("no-eligible-backup"),
                                            b(str("passive"),
                                                c(
                                                    b(str("traffic-engineering"),
                                                        c(
                                                            b(str("remote-node-id"),
                                                              ipaddr
                                                            )
                                                        )
                                                    )
                                                )
                                            ),
                                            str("secondary"),
                                            str("own-router-lsa"),
                                            b(str("bandwidth-based-metrics"),
                                                c(
                                                    b(a(str("bandwidth"), arg),
                                                        c(
                                                            a(str("metric"), arg)
                                                        )
                                                    ).as(:oneline)
                                                )
                                            ),
                                            a(str("metric"), arg),
                                            a(str("te-metric"), arg),
                                            a(str("priority"), arg),
                                            b(str("ldp-synchronization"),
                                              ldp_sync_obj
                                            ),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              )
                                            ),
                                            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),
                                                                c(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            ),
                                            b(str("bfd-liveness-detection"),
                                                c(
                                                    a(str("version"), arg),
                                                    a(str("minimum-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),
                                                            a(str("algorithm"), arg),
                                                            str("loose-check")
                                                        )
                                                    ),
                                                    str("full-neighbors-only")
                                                )
                                            ),
                                            str("dynamic-neighbors"),
                                            b(a(str("neighbor"), arg),
                                                c(
                                                    str("eligible")
                                                )
                                            ).as(:oneline),
                                            a(str("poll-interval"), arg),
                                            str("no-interface-state-traps")
                                        )
                                    ),
                                    str("no-context-identifier-advertisement"),
                                    a(str("context-identifier"), arg),
                                    b(a(str("label-switched-path"), arg),
                                        c(
                                            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),
                                                                c(
                                                                    a(str("metric"), arg)
                                                                )
                                                            ).as(:oneline)
                                                        )
                                                    )
                                                )
                                            )
                                        )
                                    ),
                                    b(a(str("peer-interface"), arg),
                                        c(
                                            c(
                                              str("disable")
                                            ),
                                            a(str("retransmit-interval"), arg),
                                            a(str("transit-delay"), arg),
                                            a(str("hello-interval"), arg),
                                            a(str("dead-interval"), arg),
                                            c(
                                              b(str("authentication"),
                                                juniper_ospf_authentication
                                              )
                                            ),
                                            str("demand-circuit"),
                                            str("flood-reduction"),
                                            str("no-neighbor-down-notification")
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("rip"),
                      juniper_protocols_rip
                    ),
                    b(str("ripng"),
                      juniper_protocols_ripng
                    ),
                    b(str("isis"),
                      juniper_protocols_isis
                    ),
                    b(str("esis"),
                      juniper_protocols_esis
                    ),
                    c(
                      b(str("l2vpn"),
                        juniper_protocols_l2vpn
                      ),
                      b(str("vpls"),
                        juniper_protocols_l2vpn
                      )
                    ),
                    b(str("pim"),
                      juniper_protocols_pim
                    ),
                    b(str("amt"),
                      juniper_protocols_amt
                    ),
                    b(str("ldp"),
                      juniper_protocols_ldp
                    ),
                    b(str("router-discovery"),
                      juniper_protocols_router_discovery
                    ),
                    b(str("msdp"),
                      juniper_protocols_msdp
                    ),
                    b(str("mvpn"),
                      juniper_protocols_mvpn
                    ),
                    b(str("igmp-snooping"),
                      juniper_protocols_igmp_snooping
                    ),
                    b(str("mpls"),
                      juniper_protocols_mpls
                    ),
                )
            ),
            b(str("bridge-domains"),
                c(
                    b(str("domain"),
                      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)
        )
      )
    end

    rule(:juniper_protocols_l2vpn) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), str("error") | str("topology") | str("nlri") | str("connections") | str("automatic-site") | str("oam") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("encapsulation-type"), arg),
            str("control-word"),
            str("no-control-word"),
            a(str("site-range"), arg),
            a(str("label-block-size"), arg),
            b(str("mac-table-size"),
                c(
                    a(str("limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            b(str("interface-mac-limit"),
                c(
                    a(str("limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("mac-statistics"),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        c(
                            a(str("limit"), arg),
                            a(str("packet-action"), arg)
                        )
                    ),
                    a(str("remote-site-id"), arg),
                    b(a(str("static-mac"), arg),
                        c(
                            a(str("vlan-id"), arg)
                        )
                    ),
                    str("no-mac-learning"),
                    a(str("description"), quote | arg)
                )
            ),
            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"),
                                  c(
                                      a(str("minimum"), arg),
                                      a(str("maximum"), arg)
                                  )
                              ).as(:oneline)
                          )
                      )
                    ),
                    str("multi-homing"),
                    a(str("site-preference"), arg),
                    a(str("mtu"), arg),
                    str("ignore-mtu-mismatch"),
                    a(str("mesh-group"), arg),
                    b(str("active-interface"),
                        c(
                            c(
                              str("any"),
                              b(str("primary"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    b(a(str("interface"), arg),
                        c(
                            b(str("interface-mac-limit"),
                                c(
                                    a(str("limit"), arg),
                                    a(str("packet-action"), arg)
                                )
                            ),
                            a(str("remote-site-id"), arg),
                            b(a(str("static-mac"), arg),
                                c(
                                    a(str("vlan-id"), arg)
                                )
                            ),
                            str("no-mac-learning"),
                            a(str("description"), quote | arg)
                        )
                    )
                )
            ),
            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"),
            b(a(str("neighbor"), arg),
                c(
                    b(str("static"),
                        c(
                            a(str("incoming-label"), arg),
                            a(str("outgoing-label"), arg)
                        )
                    ),
                    str("associate-profile"),
                    b(str("psn-tunnel-endpoint"),
                      ipv4addr
                    ),
                    a(str("community"), arg),
                    a(str("encapsulation-type"), arg),
                    str("ignore-encapsulation-mismatch"),
                    str("pseudowire-status-tlv"),
                    a(str("switchover-delay"), arg),
                    a(str("revert-time"), arg),
                    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("oam")
                )
            ),
            str("associate-profile"),
            b(a(str("mesh-group"), arg),
                c(
                    str("associate-profile"),
                    c(
                      b(str("peer-as"),
                          c(
                              str("all")
                          )
                      )
                    ),
                    a(str("vpls-id"), arg),
                    str("vrf-import"),
                    str("vrf-export"),
                    str("vrf-target"),
                    str("mac-flush"),
                    str("local-switching"),
                    str("neighbor"),
                    str("route-distinguisher").as(:oneline)
                )
            ),
            a(str("connectivity-type"), arg),
            str("oam")
        )
    end

    rule(:juniper_protocols_mvpn) do
        c(
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), str("error") | str("topology") | str("nlri") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("send"),
                            str("receive"),
                            str("detail"),
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("autodiscovery-only"),
                c(
                    b(str("intra-as"),
                        c(
                            str("inclusive")
                        )
                    )
                )
            ),
            c(
              str("receiver-site"),
              str("sender-site")
            ),
            str("unicast-umh-election"),
            b(str("mvpn-mode"),
                c(
                    c(
                      b(str("rpt-spt"),
                          c(
                              a(str("spt-switch-timer"), arg)
                          )
                      ),
                      str("spt-only")
                    )
                )
            ),
            b(str("route-target"),
                c(
                    b(str("import-target"),
                        c(
                            b(str("unicast"),
                                c(
                                    c(
                                      str("receiver"),
                                      str("sender")
                                    )
                                )
                            ).as(:oneline),
                            b(str("target"),
                                c(
                                    a(str("target-value"), 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")
                    )
                )
            )
        )
    end

    rule(:juniper_routing_instance_pbb_options) do
        c(
            a(str("peer-instance"), arg),
            b(a(str("vlan-id"), arg),
                c(
                    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(
            a(str("service-type"), arg),
            b(str("pbb-service-options"),
                c(
                    b(a(str("isid"), arg),
                        c(
                            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
                    )
                )
            )
        )
      )
    end

    rule(:juniper_routing_instance_switch_options) do
        c(
            b(str("mac-table-size"),
                c(
                    a(str("limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            b(str("interface-mac-limit"),
                c(
                    a(str("limit"), arg),
                    a(str("packet-action"), arg)
                )
            ),
            a(str("mac-table-aging-time"), arg),
            str("no-mac-learning"),
            str("mac-statistics"),
            a(str("service-id"), arg),
            b(a(str("interface"), arg),
                c(
                    b(str("interface-mac-limit"),
                        c(
                            a(str("limit"), arg),
                            a(str("packet-action"), arg)
                        )
                    ),
                    a(str("remote-site-id"), arg),
                    b(a(str("static-mac"), arg),
                        c(
                            a(str("vlan-id"), arg)
                        )
                    ),
                    str("no-mac-learning"),
                    a(str("description"), quote | arg)
                )
            )
        )
    end

    rule(:juniper_routing_options) do
        c(
            a(str("med-igp-update-interval"), arg),
            b(str("bmp"),
                c(
                    b(str("station-address"),
                      ipv4addr
                    ),
                    a(str("station-port"), arg),
                    a(str("statistics-timeout"), arg),
                    a(str("memory-limit"), arg)
                )
            ),
            str("bgp-orf-cisco-mode"),
            b(str("ppm"),
                c(
                    str("no-delegate-processing")
                )
            ),
            b(str("source-routing"),
                c(
                    str("ip"),
                    str("ipv6")
                )
            ),
            b(a(str("srlg"), arg),
                c(
                    a(str("srlg-value"), arg),
                    a(str("srlg-cost"), arg)
                )
            ),
            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)
                )
            ),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      trace_file_type
                    ),
                    a(str("flag"), str("parse") | str("regex-parse") | str("config-internal") | str("nsr-synchronization") | str("condition-manager") | str("graceful-restart") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                        c(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            b(str("options"),
                c(
                    b(str("syslog"),
                        c(
                            b(str("level"),
                                c(
                                    str("emergency"),
                                    str("alert"),
                                    str("critical"),
                                    str("error"),
                                    str("warning"),
                                    str("notice"),
                                    str("info"),
                                    str("debug")
                                )
                            ).as(:oneline),
                            a(str("upto"), arg)
                        )
                    ),
                    a(str("mark"), arg)
                )
            ),
            b(str("graceful-restart"),
                c(
                    c(
                      str("disable")
                    ),
                    a(str("restart-duration"), arg)
                )
            ),
            str("nonstop-routing"),
            b(str("interface-routes"),
                c(
                    b(str("rib-group"),
                      rib_group_type
                    ),
                    a(str("family"), str("inet") | str("inet6"),
                        c(
                            b(str("import"),
                              policy_algebra
                            ),
                            b(str("export"),
                                c(
                                    str("point-to-point"),
                                    str("lan")
                                )
                            )
                        )
                    )
                )
            ),
            b(a(str("rib"), arg),
                c(
                    b(str("static"),
                        c(
                            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"),
                                    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"),
                                      ca(
                                            a(str("origin"), arg),
                                            str("atomic-aggregate"),
                                            b(str("aggregator"),
                                                ca(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            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
                                    ),
                                    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
                                    ),
                                    a(str("backup-pe-group"), arg),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            a(str("version"), arg),
                                            a(str("minimum-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),
                                                    a(str("algorithm"), arg),
                                                    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"),
                                    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"),
                                      ca(
                                            a(str("origin"), arg),
                                            str("atomic-aggregate"),
                                            b(str("aggregator"),
                                                ca(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            ),
                            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
                                    ),
                                    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
                                    ),
                                    a(str("backup-pe-group"), arg),
                                    b(str("bfd-liveness-detection"),
                                        c(
                                            a(str("version"), arg),
                                            a(str("minimum-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),
                                                    a(str("algorithm"), arg),
                                                    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"),
                                    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"),
                                      ca(
                                            a(str("origin"), arg),
                                            str("atomic-aggregate"),
                                            b(str("aggregator"),
                                                ca(
                                                    b(str("address"),
                                                      ipv4addr
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("martians"),
                      martian_type
                    ),
                    b(str("aggregate"),
                      rib_aggregate_type
                    ),
                    b(str("generate"),
                      rib_aggregate_type
                    ),
                    c(
                      b(str("maximum-paths"),
                          c(
                              a(str("limit"), arg),
                              c(
                                a(str("threshold"), arg),
                                str("log-only")
                              ),
                              a(str("log-interval"), arg)
                          )
                      ).as(:oneline)
                    ),
                    b(str("maximum-prefixes"),
                        c(
                            a(str("limit"), 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"),
                                c(
                                    str("equal-external-internal")
                                )
                            ).as(:oneline),
                            str("as-path-compare")
                        )
                    ),
                    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)
                                )
                            )
                        )
                    ),
                    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("static"),
                c(
                    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"),
                            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"),
                              ca(
                                    a(str("origin"), arg),
                                    str("atomic-aggregate"),
                                    b(str("aggregator"),
                                        ca(
                                            b(str("address"),
                                              ipv4addr
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    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
                            ),
                            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
                            ),
                            a(str("backup-pe-group"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    a(str("version"), arg),
                                    a(str("minimum-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),
                                            a(str("algorithm"), arg),
                                            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"),
                            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"),
                              ca(
                                    a(str("origin"), arg),
                                    str("atomic-aggregate"),
                                    b(str("aggregator"),
                                        ca(
                                            b(str("address"),
                                              ipv4addr
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    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
                            ),
                            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
                            ),
                            a(str("backup-pe-group"), arg),
                            b(str("bfd-liveness-detection"),
                                c(
                                    a(str("version"), arg),
                                    a(str("minimum-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),
                                            a(str("algorithm"), arg),
                                            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"),
                            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"),
                              ca(
                                    a(str("origin"), arg),
                                    str("atomic-aggregate"),
                                    b(str("aggregator"),
                                        ca(
                                            b(str("address"),
                                              ipv4addr
                                            )
                                        )
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("martians"),
              martian_type
            ),
            b(str("aggregate"),
              rib_aggregate_type
            ),
            b(str("generate"),
              rib_aggregate_type
            ),
            c(
              b(str("maximum-paths"),
                  c(
                      a(str("limit"), arg),
                      c(
                        a(str("threshold"), arg),
                        str("log-only")
                      ),
                      a(str("log-interval"), arg)
                  )
              ).as(:oneline)
            ),
            b(str("maximum-prefixes"),
                c(
                    a(str("limit"), 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"),
                        c(
                            str("equal-external-internal")
                        )
                    ).as(:oneline),
                    str("as-path-compare")
                )
            ),
            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)
                        )
                    )
                )
            ),
            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("rib-groups"),
              rpd_rib_group_type
            ),
            str("route-record"),
            b(str("router-id"),
              ipv4addr
            ),
            b(str("route-distinguisher-id"),
              ipv4addr
            ),
            b(str("autonomous-system"),
                ca(
                    a(str("loops"), arg),
                    str("asdot-notation"),
                    b(str("independent-domain"),
                        c(
                            str("no-attrset")
                        )
                    ).as(:oneline)
                )
            ).as(:oneline),
            b(str("confederation"),
                sca(
                    a(str("members"), arg)
                )
            ).as(:oneline),
            b(str("forwarding-table"),
              forwarding_table_type
            ),
            b(str("resolution"),
                c(
                    b(str("tracefilter"),
                      policy_algebra
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), str("event") | str("flash") | str("kernel") | str("indirect") | str("task") | str("all"),
                                c(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(a(str("rib"), arg),
                        c(
                            a(str("resolution-ribs"), arg),
                            b(str("import"),
                              policy_algebra
                            )
                        )
                    )
                )
            ),
            b(str("multicast"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), str("parse") | str("config-internal") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                c(
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    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"),
                                c(
                                    a(str("bandwidth-value"), arg),
                                    str("adaptive")
                                )
                            ).as(:oneline),
                            b(str("redundant-sources"),
                              ipaddr
                            ),
                            b(str("forwarding-cache"),
                                c(
                                    b(str("timeout"),
                                        c(
                                            c(
                                              a(str("timeout-value"), arg),
                                              b(str("never"),
                                                  c(
                                                      str("non-discard-entry-only")
                                                  )
                                              )
                                            )
                                        )
                                    ).as(:oneline)
                                )
                            )
                        )
                    ),
                    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(
                            b(str("threshold"),
                                c(
                                    a(str("suppress"), arg),
                                    a(str("reuse"), 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(a(str("backup-pe-group"), arg),
                        c(
                            b(str("backups"),
                              ipaddr
                            ),
                            b(str("local-address"),
                              ipaddr
                            )
                        )
                    )
                )
            ),
            b(str("instance-import"),
              policy_algebra
            ),
            b(str("instance-export"),
              policy_algebra
            ),
            b(str("auto-export"),
                c(
                    c(
                      str("disable")
                    ),
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), str("export") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                                c(
                                    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("dynamic-tunnels"),
                c(
                    b(str("traceoptions"),
                        c(
                            b(str("file"),
                              trace_file_type
                            ),
                            a(str("flag"), str("kernel") | str("tunnel") | str("task") | str("all"),
                                c(
                                    str("send"),
                                    str("receive"),
                                    str("detail"),
                                    str("disable")
                                )
                            ).as(:oneline)
                        )
                    ),
                    dynamic_tunnel_type
                )
            ),
            b(str("flow"),
                c(
                    b(str("validation"),
                        c(
                            b(str("traceoptions"),
                              flow_dep_traceoptions
                            )
                        )
                    ),
                    b(a(str("route"), arg),
                        c(
                            b(str("match"),
                              flow_route_qualifier
                            ),
                            b(str("then"),
                              flow_route_op
                            )
                        )
                    ),
                    a(str("term-order"), arg)
                )
            ),
            b(str("topologies"),
                c(
                    a(str("family"), str("inet") | str("inet6"),
                        c(
                            a(str("topology"), arg)
                        )
                    )
                )
            ),
            b(str("fate-sharing"),
                c(
                    b(a(str("group"), arg),
                        c(
                            a(str("cost"), arg),
                            b(str("from"),
                              fate_sharing_links
                            )
                        )
                    )
                )
            )
        )
    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
                      )
                  )
              ),
              str("gre"),
              str("udp"),
            ),
            b(str("destination-networks"),
              network_type
            )
        )
      )
    end

    rule(:export_af_obj) do
        c(
            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(
            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_dep_traceoptions) do
        c(
            b(str("file"),
              trace_file_type
            ),
            a(str("flag"), str("resolution") | str("flash") | str("route") | str("normal") | str("general") | str("state") | str("policy") | str("task") | str("timer") | str("all"),
                c(
                    str("send"),
                    str("receive"),
                    str("detail"),
                    str("disable"),
                    b(str("filter"),
                        c(
                            a(str("match-on"), arg),
                            b(str("policy"),
                              policy_algebra
                            )
                        )
                    ).as(:oneline)
                )
            ).as(:oneline)
        )
    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"),
            str("next-term")
        )
    end

    rule(:flow_route_qualifier) do
        c(
            b(str("destination"),
              ipprefix
            ),
            b(str("source"),
              ipprefix
            ),
            a(str("protocol"), arg),
            a(str("port"), arg),
            a(str("destination-port"), arg),
            a(str("source-port"), arg),
            a(str("icmp-type"), arg),
            a(str("icmp-code"), arg),
            a(str("tcp-flags"), arg),
            b(str("packet-length"),
              policy_algebra
            ),
            b(str("dscp"),
              policy_algebra
            ),
            a(str("fragment"), arg)
        )
    end

    rule(:forwarding_table_type) do
        c(
            b(str("export"),
              policy_algebra
            ),
            str("indirect-next-hop"),
            str("no-indirect-next-hop"),
            str("indirect-next-hop-change-acknowledgements"),
            str("no-indirect-next-hop-change-acknowledgements"),
            str("indexed-next-hop"),
            a(str("unicast-reverse-path"), arg),
            str("chained-composite-next-hop")
        )
    end

    rule(:juniper_sampling_options) do
        c(
            c(
              str("disable")
            ),
            b(str("traceoptions"),
              sampling_traceoptions_type
            ),
            str("sample-once"),
            b(str("input"),
              sampling_input_type
            ),
            b(str("family"),
                c(
                    b((str("inet") | str("mpls")),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("output"),
                              sampling_instance_inet_global_output_type
                            )
                        )
                    ),
                    b(str("inet6"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("output"),
                              sampling_family_inet6_output_type
                            )
                        )
                    )
                )
            ),
            b(a(str("instance"), arg),
              c(
                str("disable"),
                b(str("input"),
                  c(
                    a(str("rate"), arg),
                    a(str("run-length"), arg),
                    a(str("max-packets-per-second"), arg),
                    a(str("maximum-packet-length"), arg)
                  )
                ),
                a(str("family"), str("mpls") | str("inet6") | str("inet") ,
                  c(
                    str("disable"),
                    b(str("output"),
                      c(
                        a(str("aggregate-export-interval"), arg),
                        a(str("flow-active-timeout"), arg),
                        a(str("flow-inactive-timeout"), arg),
                        a(str("extension-service"), arg),
                        b(a(str("flow-server"), arg),
                          c(
                            b(str("aggregation"),
                              c(
                                str("autonomous-system"),
                                str("destination-prefix"),
                                str("protocol-port"),
                                b(str("source-destination-prefix"),
                                  str("caida-compliant")
                                ),
                                str("source-prefix")
                              )
                            ),
                            a(str("autonomous-system-type"), str("origin") | str("peer")),
                            (str("local-dump") | str("no-local-dump")),
                            a(str("port"), arg),
                            a(str("source-address"), ipaddr),
                            a(str("version"), arg),
                            b(str("version9"),
                              a(str("template"), arg)
                            )
                          )
                        ),
                        b(a(str("interface"), arg),
                          c(
                            a(str("engine-id"), arg),
                            a(str("engine-type"), arg),
                            a(str("source-address"), ipaddr)
                          )
                        ),
                        b(str("inline-jflow"),
                          a(str("source-address"), ipaddr),
                          a(str("flow-export-rate"), arg)
                        )
                      )
                    )
                  )
                )
              )
            )
        )
    end

    rule(:juniper_services_captive_portal) do
        c(
            a(str("authentication-profile-name"), arg),
            b(str("traceoptions"),
                c(
                    b(str("file"),
                      esp_trace_file_type
                    ),
                    a(str("flag"), str("dot1x-debug") | str("parse") | str("esw-if") | str("config-internal") | str("normal") | str("general") | str("state") | str("task") | str("timer") | str("all"),
                        c(
                            str("disable")
                        )
                    ).as(:oneline)
                )
            ),
            a(str("interface"), str("all") | arg,
                c(
                    a(str("supplicant"), arg),
                    a(str("retries"), arg),
                    a(str("quiet-period"), arg),
                    a(str("server-timeout"), arg),
                    a(str("session-expiry"), arg)
                )
            ),
            a(str("secure-authentication"), arg),
            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(
            b(str("autoinstallation"),
                c(
                    b(a(str("interfaces"), arg),
                        c(
                            str("bootp"),
                            str("rarp"),
                            str("slarp")
                        )
                    ),
                    b(a(str("configuration-servers"), arg),
                        c(
                            b(str("password"),
                              unreadable
                            )
                        )
                    ).as(:oneline),
                    str("usb")
                )
            ),
            a(str("host-name"), arg),
            str("auto-snapshot"),
            a(str("domain-name"), arg),
            a(str("domain-search"), arg),
            b(str("backup-router"),
                c(
                    b(str("address"),
                      ipv4addr
                    ),
                    b(str("destination"),
                      ipv4prefix
                    )
                )
            ).as(:oneline),
            b(str("inet6-backup-router"),
                c(
                    b(str("address"),
                      ipv6addr
                    ),
                    b(str("destination"),
                      ipv6prefix
                    )
                )
            ).as(:oneline),
            a(str("time-zone"), arg),
            str("use-imported-time-zones"),
            str("no-debugger-on-alt-break"),
            str("default-address-selection"),
            a(str("nd-maxmcast-solicit"), arg),
            a(str("nd-retrasmit-timer"), arg),
            str("no-neighbor-learn"),
            str("no-multicast-echo"),
            str("no-redirects"),
            str("no-ping-record-route"),
            str("no-ping-time-stamp"),
            a(str("dump-device"), arg),
            b(str("arp"),
                c(
                    a(str("aging-timer"), arg),
                    b(str("interfaces"),
                        c(
                            b(str("arp-interface"),
                              arp_interface_type
                            )
                        )
                    ),
                    str("passive-learning"),
                    str("purging"),
                    str("gratuitous-arp-on-ifup"),
                    a(str("gratuitous-arp-delay"), arg)
                )
            ),
            a(str("saved-core-files"), arg),
            str("saved-core-context"),
            str("no-saved-core-context"),
            str("kernel-replication"),
            str("mirror-flash-on-disk"),
            b(str("internet-options"),
                c(
                    b(str("icmpv4-rate-limit"),
                        c(
                            a(str("packet-rate"), arg),
                            a(str("bucket-size"), arg)
                        )
                    ).as(:oneline),
                    b(str("icmpv6-rate-limit"),
                        c(
                            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),
                    a(str("no-tcp-reset"), arg)
                )
            ),
            a(str("authentication-order"), arg),
            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("root-authentication"),
              authentication_object
            ),
            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("radius-options"),
                c(
                    a(str("password-protocol"), arg),
                    b(str("attributes"),
                        c(
                            b(str("nas-ip-address"),
                              ipaddr
                            )
                        )
                    )
                )
            ),
            b(str("tacplus-options"),
                c(
                    a(str("service-name"), arg),
                    c(
                      str("no-cmd-attribute-value"),
                      str("exclude-cmd-attribute")
                    ),
                    str("timestamp-and-timezone")
                )
            ),
            b(str("accounting"),
                c(
                    a(str("events"), arg),
                    b(str("traceoptions"),
                        c(
                            str("no-remote-trace"),
                            b(str("file"),
                                sca(
                                    a(str("size"), arg),
                                    a(str("files"), arg),
                                    str("world-readable"),
                                    str("no-world-readable")
                                )
                            ).as(:oneline),
                            a(str("flag"), str("all") | str("events") | str("config") | str("radius")).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("donot-disable-ip6op-ondad"),
            b(str("scripts"),
              scripts_type
            ),
            b(str("login"),
                c(
                    a(str("announcement"), arg),
                    a(str("message"), arg),
                    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)
                        )
                    ),
                    b(str("class"),
                      login_class_object
                    ),
                    b(str("user"),
                      login_user_object
                    ),
                    b(str("password"),
                        c(
                            a(str("minimum-length"), arg),
                            a(str("maximum-length"), arg),
                            a(str("change-type"), arg),
                            a(str("minimum-changes"), arg),
                            a(str("format"), arg)
                        )
                    ),
                    b(str("deny-sources"),
                        c(
                            b(str("address"),
                              ipprefix_optional
                            )
                        )
                    )
                )
            ),
            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("services"),
                c(
                    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("ssh"),
                        c(
                            a(str("root-login"), arg),
                            c(
                              str("tcp-forwarding"),
                              str("no-tcp-forwarding"),
                              str("no-passwords"),
                              str("no-public-keys")
                            ),
                            a(str("protocol-version"), arg),
                            a(str("max-sessions-per-connection"), arg),
                            a(str("ciphers"), arg),
                            a(str("macs"), arg),
                            a(str("key-exchange"), arg),
                            a(str("client-alive-count-max"), arg),
                            a(str("client-alive-interval"), arg),
                            b(str("hostkey-algorithm"),
                                c(
                                    c(
                                      str("no-ssh-dss"),
                                      str("ssh-dss")
                                    ),
                                    c(
                                      str("no-ssh-rsa"),
                                      str("ssh-rsa")
                                    ),
                                    c(
                                      str("no-ssh-ecdsa"),
                                      str("ssh-ecdsa")
                                    ),
                                    c(
                                      str("no-ssh-ed25519"),
                                      str("ssh-ed25519")
                                    )
                                )
                            ),
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg),
                            a(str("authentication-order"), any)
                        )
                    ),
                    b(str("telnet"),
                        c(
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg)
                        )
                    ),
                    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),
                            a(str("connection-limit"), arg),
                            a(str("rate-limit"), arg)
                        )
                    ),
                    b(str("netconf"),
                        c(
                            b(str("ssh"),
                                c(
                                    a(str("connection-limit"), arg),
                                    a(str("rate-limit"), arg),
                                    a(str("port"), arg)
                                )
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("all") | str("incoming") | str("outgoing")).as(:oneline),
                                    str("on-demand")
                                )
                            )
                        )
                    ),
                    str("flow-tap-dtcp"),
                    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"),
                                        sca(
                                            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("level"), arg),
                                    a(str("flag"), str("ddns") | str("config") | str("ui") | str("rtsock") | str("all") | str("trace")).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("dns-proxy"),
                                c(
                                    a(str("propogate-setting"), arg),
                                    a(str("interface"), arg),
                                    b(a(str("default-domain"), arg),
                                        c(
                                            a(str("forwarders"), arg)
                                        )
                                    ),
                                    b(a(str("cache"), arg),
                                        c(
                                            b(str("inet"),
                                              ipaddr
                                            )
                                        )
                                    ).as(:oneline),
                                    b(a(str("view"), arg),
                                        c(
                                            a(str("match-clients"), arg),
                                            b(a(str("domain"), arg),
                                                c(
                                                    str("forward-only"),
                                                    a(str("forwarders"), 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"),
                                        sca(
                                            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"), str("beep") | str("profile") | str("application") | str("io") | str("all")).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("outbound-ssh"),
                        c(
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("configuration") | str("connectivity") | str("all")).as(:oneline)
                                )
                            ),
                            b(a(str("client"), arg),
                                c(
                                    a(str("device-id"), arg),
                                    b(str("secret"),
                                      unreadable
                                    ),
                                    b(str("keep-alive"),
                                        c(
                                            a(str("retry"), arg),
                                            a(str("timeout"), arg)
                                        )
                                    ),
                                    a(str("reconnect-strategy"), arg),
                                    a(str("services"), arg),
                                    b(a(str("servers"), arg),
                                        c(
                                            a(str("port"), arg),
                                            a(str("retry"), arg),
                                            a(str("timeout"), arg)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    b(str("subscriber-management-helper"),
                      smihelperd_type
                    ),
                    b(str("dhcp-local-server"),
                      jdhcp_local_server_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)
                                )
                            )
                        )
                    ),
                    str("packet-triggered-subscribers"),
                    b(str("static-subscribers"),
                      jsscd_static_subscribers_type
                    ),
                    str("local-policy-decision-function"),
                    b(str("subscriber-management"),
                      smid_type
                    ),
                    b(str("dhcp"),
                        c(
                            a(str("maximum-lease-time"), arg),
                            a(str("default-lease-time"), 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),
                                c(
                                    c(
                                      a(str("flag"), arg),
                                      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(
                                                a(str("flag"), arg),
                                                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"),
                                        c(
                                            b(str("low"),
                                              ipv4addr
                                            ),
                                            b(str("high"),
                                              ipv4addr
                                            )
                                        )
                                    ).as(:oneline),
                                    a(str("exclude-address"), arg),
                                    a(str("maximum-lease-time"), arg),
                                    a(str("default-lease-time"), 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),
                                        c(
                                            c(
                                              a(str("flag"), arg),
                                              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(
                                                        a(str("flag"), arg),
                                                        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)
                                        )
                                    ),
                                    a(str("propagate-settings"), arg),
                                    b(str("propagate-ppp-settings"),
                                      interface_name
                                    )
                                )
                            ),
                            b(a(str("static-binding"), arg),
                                c(
                                    a(str("fixed-address"), arg),
                                    a(str("host-name"), arg),
                                    b(str("client-identifier"),
                                        c(
                                            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),
                                        c(
                                            c(
                                              a(str("flag"), arg),
                                              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(
                                                        a(str("flag"), arg),
                                                        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)
                                        )
                                    )
                                )
                            ),
                            a(str("propagate-settings"), arg),
                            b(str("propagate-ppp-settings"),
                              interface_name
                            )
                        )
                    ),
                    b(str("dynamic-dns"),
                        c(
                            b(a(str("client"), arg),
                                c(
                                    a(str("server"), arg),
                                    a(str("agent"), arg),
                                    a(str("username"), arg),
                                    b(str("password"),
                                      unreadable
                                    ),
                                    b(str("interface"),
                                      interface_name
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            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("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),
                            a(str("facility-override"), arg),
                            a(str("log-prefix"), arg),
                            b(str("source-address"),
                              ipaddr
                            ),
                            str("explicit-priority"),
                            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"),
                            b(str("structured-data"),
                                c(
                                    c(
                                      str("brief")
                                    )
                                )
                            )
                        )
                    ),
                    a(str("console"), 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"),
                        c(
                            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"),
                        c(
                            str("year"),
                            str("millisecond")
                        )
                    ).as(:oneline),
                    b(str("source-address"),
                      ipaddr
                    ),
                    a(str("log-rotate-frequency"), arg)
                )
            ),
            b(str("tracing"),
                c(
                    b(str("destination-override"),
                        c(
                            b(str("syslog"),
                                c(
                                    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")
                            ),
                            b(a(str("archive-sites"), arg),
                                c(
                                    b(str("password"),
                                      unreadable
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            ),
            b(str("extensions"),
                c(
                    b(a(str("providers"), arg),
                        c(
                            b(a(str("license-type"), arg),
                                c(
                                    a(str("deployment-scope"), arg)
                                )
                            ).as(:oneline)
                        )
                    ),
                    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("commit"),
                c(
                    str("synchronize"),
                    b(str("server"),
                        c(
                            a(str("maximum-aggregate-pool"), arg),
                            a(str("maximum-entries"), arg),
                            a(str("commit-interval"), arg),
                            a(str("days-to-keep-error-logs"), arg),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            a(str("size"), arg),
                                            a(str("files"), arg),
                                            str("world-readable"),
                                            str("no-world-readable"),
                                            str("microsecond-stamp")
                                        )
                                    ).as(:oneline),
                                    a(str("flag"), str("all") | str("commit-server") | str("batch") | str("configuration")).as(:oneline)
                                )
                            )
                        )
                    )
                )
            ),
            b(str("fips"),
                c(
                    a(str("level"), arg),
                    b(str("self-test"),
                        c(
                            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("auto-configuration"),
                c(
                    b(str("traceoptions"),
                      autoconf_traceoptions_type
                    )
                )
            ),
            b(str("processes"),
                c(
                    b(str("routing"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg)
                        )
                    ).as(:oneline),
                    str("software-forwarding").as(:oneline),
                    str("packet-forwarding-engine").as(:oneline),
                    b(str("chassis-control"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg)
                        )
                    ).as(:oneline),
                    b(str("service-pics"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg)
                        )
                    ).as(:oneline),
                    b(str("ntp"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg)
                        )
                    ).as(:oneline),
                    b(str("watchdog"),
                        c(
                            c(
                              str("enable"),
                              str("disable")
                            ),
                            a(str("timeout"), arg)
                        )
                    ).as(:oneline),
                    b(str("process-monitor"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                              pmond_traceoptions_type
                            )
                        )
                    ),
                    b(str("resource-cleanup"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                              res_cleanupd_traceoptions_type
                            )
                        )
                    ),
                    b(str("routing-socket-proxy"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg)
                        )
                    ).as(:oneline),
                    b(str("web-management"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg)
                        )
                    ).as(:oneline),
                    b(str("named-service"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg)
                        )
                    ),
                    b(str("cfm"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    b(str("general-authentication-service"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), 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("all")).as(:oneline)
                                )
                            )
                        )
                    ),
                    b((str("dhcp-service") | str("dhcp")),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg),
                            b(str("traceoptions"),
                              jdhcp_traceoptions_level_type
                            ),
                            b(str("interface-traceoptions"),
                              jdhcp_interface_traceoptions_level_type
                            )
                        )
                    ),
                    b(str("diameter-service"),
                        c(
                            c(
                              str("disable")
                            ),
                            str("traceoptions")
                        )
                    ),
                    str("mac-validation"),
                    b(str("sbc-configuration-process"),
                        c(
                            c(
                              str("disable")
                            ),
                            a(str("failover"), arg),
                            b(str("traceoptions"),
                              sbc_traceoptions
                            )
                        )
                    ),
                    b(str("sdk-service"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                              ssd_traceoptions_type
                            )
                        )
                    ),
                    b(str("datapath-trace-service"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                              datapath_traced_traceoptions_type
                            )
                        )
                    ),
                    b(str("send"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    b(str("static-subscribers"),
                        c(
                            c(
                              str("disable")
                            ),
                            str("traceoptions")
                        )
                    ),
                    b(str("daemon-process"),
                      daemon_process
                    ),
                    b(str("dialer-services"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("config") | str("kernel") | str("route") | str("interface") | str("error") | str("memory") | str("all")).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("isdn-signaling"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("daemon") | str("stack") | str("all")).as(:oneline)
                                )
                            ),
                            str("reject-incoming")
                        )
                    ),
                    str("telephony-gateway-module"),
                    str("wireless-wan-service"),
                    str("wireless-lan-service"),
                    b(str("network-security"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    b(str("firewall-authentication-service"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    b(str("jsrp-service"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    b(str("wan-acceleration"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("configuration") | str("ssam") | str("memory") | str("fpc-ipc") | str("fpc-ipc-heart-beat") | str("wx-login") | str("all")).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("smtpd-service"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ).as(:oneline),
                    b(str("logical-system-service"),
                        c(
                            c(
                              str("disable")
                            ),
                            b(str("traceoptions"),
                                c(
                                    str("no-remote-trace"),
                                    b(str("file"),
                                        sca(
                                            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"), str("configuration") | str("all")).as(:oneline)
                                )
                            )
                        )
                    ),
                    b(str("system-health-management"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ),
                    b(str("system-log-vital"),
                        c(
                            c(
                              str("disable")
                            )
                        )
                    ),
                    b(str("app-engine-management-service"),
                      app_engine_management_service
                    ),
                    b(str("app-engine-virtual-machine-management-service"),
                      app_engine_management_service
                    )
                )
            ),
            str("ddos-protection"),
            str("packet-triggered-subscribers-partition"),
            b(str("ntp"),
                c(
                    b(str("boot-server"),
                      ipaddr
                    ),
                    b(a(str("authentication-key"), arg),
                        c(
                            a(str("type"), arg),
                            b(str("value"),
                              unreadable
                            )
                        )
                    ).as(:oneline),
                    b(a(str("peer"), arg),
                        c(
                            a(str("key"), arg),
                            a(str("version"), arg),
                            str("prefer")
                        )
                    ).as(:oneline),
                    b(a(str("server"), arg),
                        c(
                            a(str("key"), arg),
                            a(str("version"), arg),
                            str("prefer")
                        )
                    ).as(:oneline),
                    b(a(str("broadcast"), arg),
                        c(
                            a(str("key"), arg),
                            a(str("version"), arg),
                            a(str("ttl"), arg)
                        )
                    ).as(:oneline),
                    str("broadcast-client"),
                    b(str("multicast-client"),
                        c(
                            b(str("address"),
                              ipaddr
                            )
                        )
                    ).as(:oneline),
                    a(str("trusted-key"), arg),
                    b(str("source-address"),
                      ipaddr
                    )
                )
            ),
            b(str("log-vital"),
                c(
                    a(str("interval"), arg),
                    a(str("files"), arg),
                    a(str("storage-limit"), arg),
                    a(str("file-size"), arg),
                    b(a(str("add"), arg),
                        c(
                            b(str("comment"),
                                c(
                                    a(str("comment-string"), arg)
                                )
                            )
                        )
                    ),
                    b(str("group"),
                        c(
                            str("operating"),
                            str("idp"),
                            str("storage"),
                            str("cluster-counter"),
                            a(str("screen"), arg),
                            a(str("spu"), arg)
                        )
                    )
                )
            ),
            str("security-profile")
        )
    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),
                c(
                    b(str("password"),
                      unreadable
                    )
                )
            ).as(:oneline)
        ).as(:oneline)
    end

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

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

    rule(:autoconf_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), str("configuration") | str("interfaces") | str("io") | str("rtsock") | str("ui") | str("auth") | str("all")).as(:oneline)
        )
    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"),
                sca(
                    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"), 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(
            c(
              str("disable")
            ),
            a(str("failover"), arg),
            a(str("command"), arg)
        )
      ).as(:oneline)
    end

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

    rule(:dhcp_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), 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") | str("client")).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"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), 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"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), str("state") | str("packet") | str("all")).as(:oneline)
        )
    end

    rule(:jdhcp_traceoptions_level_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), str("state") | str("packet") | str("all") | str("database") | str("interface") | str("rtsock") | str("io") | str("ha") | str("ui") | str("general") | str("fwd") | str("rpd") | str("auth") | str("profile") | str("session-db") | str("performance") | str("statistics") | str("liveness-detection")).as(:oneline)
        )
    end

    rule(:juniper_accounting_options) do
        c(
            str("policy-decision-statistics-profile"),
            str("selective-aggregate-interface-stats").as(:oneline),
            b(str("periodic-refresh"),
                c(
                    c(
                      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
                    ),
                    b(a(str("archive-sites"), arg),
                        c(
                            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),
                    a(str("operation"), arg),
                    b(str("object-names"),
                      mib_variable_name_object
                    )
                )
            )
        )
    end

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

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

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

    rule(:layer2_pm_family_output_type) do
        c(
            c(
              b(str("interface"),
                interface_name
              ),
              a(str("next-hop-group"), arg)
            ),
            str("no-filter-check")
        )
    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)
        )
      )
    end

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

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

    rule(:license_object) do
        c(
            b(str("autoupdate"),
                c(
                    b(a(str("url"), arg),
                        c(
                            a(str("password"), arg)
                        )
                    ).as(:oneline)
                )
            ),
            b(str("renew"),
                c(
                    a(str("before-expiration"), arg),
                    a(str("interval"), arg)
                )
            ).as(:oneline),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sca(
                            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"), str("all") | str("events") | str("config")).as(:oneline)
                )
            )
        )
    end

    rule(:lmp_control_channel_type) do
      b(arg.as(:arg),
        c(
            b(str("remote-address"),
              ipaddr
            )
        )
      )
    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(:login_class_object) do
      b(arg.as(:arg),
        c(
            a(str("allowed-days"), arg),
            b(str("access-start"),
              time
            ),
            b(str("access-end"),
              time
            ),
            a(str("idle-timeout"), arg),
            a(str("logical-system"), arg),
            str("login-alarms"),
            a(str("login-script"), arg),
            str("login-tip"),
            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("security-role"), arg),
            a(str("allow-configuration-regexps"), arg),
            a(str("deny-configuration-regexps"), arg)
        )
      )
    end

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

        rule(:login_user_object) do
          b(arg.as(:arg),
            sc(
                a(str("full-name"), quote | 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"), arg | arg | str("interface-unit-number"),
                c(
                    b(str("peer-psd"),
                        c(
                            a(str("psd-name"), arg)
                        )
                    ).as(:oneline),
                    b(str("peer-interface"),
                        c(
                            b(str("interface-name"),
                              interface_unit
                            )
                        )
                    ),
                    b(str("interface-shared-with"),
                        c(
                            a(str("psd-name"), arg)
                        )
                    ),
                    c(
                      str("disable")
                    ),
                    str("passive-monitor-mode"),
                    str("per-session-scheduler"),
                    str("clear-dont-fragment-bit"),
                    str("reassemble-packets"),
                    str("rpm"),
                    a(str("description"), quote | arg),
                    a(str("metadata"), arg),
                    str("dial-options"),
                    b(str("demux-source"),
                          (str("inet") | str("inet6"))
                    ),
                    b(str("demux-destination"),
                          (str("inet") | str("inet6"))
                    ),
                    a(str("encapsulation"), arg),
                    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"),
                    b(str("arp-resp"),
                        c(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    b(str("proxy-arp"),
                        c(
                            c(
                              str("unrestricted"),
                              str("restricted")
                            )
                        )
                    ).as(:oneline),
                    c(
                      a(str("vlan-id"), arg),
                      a(str("vlan-id-range"), arg),
                      a(str("vlan-id-list"), arg),
                      b(str("vlan-tags"),
                          c(
                              a(str("outer"), arg),
                              c(
                                a(str("inner"), arg),
                                a(str("inner-range"), arg),
                                a(str("inner-list"), arg)
                              )
                          )
                      ).as(:oneline)
                    ),
                    a(str("native-inner-vlan-id"), arg),
                    str("inner-vlan-id-range").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"),
                        c(
                            c(
                              str("cell"),
                              str("aal5")
                            )
                        )
                    ).as(:oneline),
                    b(str("vci-range"),
                        c(
                            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"),
                        c(
                            c(
                              a(str("oam-period"), arg),
                              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("demux-options"),
                      demux_options_type
                    ),
                    str("targetted-distribution"),
                    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),
                    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),
                                    a(str("queues"), arg),
                                    b(str("port"),
                                        c(
                                            a(str("minimum"), arg),
                                            a(str("maximum"), arg)
                                        )
                                    ).as(:oneline),
                                    b(str("maximum-contexts"),
                                        c(
                                            a(str("number"), 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("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
                    ),
                    str("atm-policer"),
                    str("layer2-policer"),
                    str("filter"),
                    b(str("multi-chassis-protection"),
                      multi_chassis_protection_group
                    ),
                    b(str("family"),
                        c(
                            b(str("inet"),
                                c(
                                    b(str("targeted-broadcast"),
                                        c(
                                            c(
                                              str("forward-and-send-to-re"),
                                              str("forward-only")
                                            )
                                        )
                                    ),
                                    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")
                                        )
                                    ),
                                    a(str("mac-validate"), arg),
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                c(
                                                    str("loose")
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    a(str("mtu"), arg),
                                    str("no-redirects"),
                                    str("no-neighbor-learn"),
                                    str("unconditional-src-learn"),
                                    str("multicast-only"),
                                    str("primary"),
                                    a(str("ipsec-sa"), arg),
                                    str("demux-source"),
                                    str("demux-destination"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  ca(
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  ca(
                                                      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),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg),
                                            a(str("dialer"), arg)
                                        )
                                    ),
                                    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(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"),
                                                        c(
                                                            c(
                                                              a(str("oam_period"), arg),
                                                              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),
                                                c(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicaset
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(str("web-authentication"),
                                                c(
                                                    str("http"),
                                                    str("https"),
                                                    str("redirect-to-https")
                                                )
                                            ),
                                            b(str("vrrp-group"),
                                              vrrp_group
                                            )
                                        )
                                    ),
                                    b(str("unnumbered-address"),
                                        c(
                                            b(str("source"),
                                              interface_unit
                                            ),
                                            a(str("preferred-source-address"), arg),
                                            b(str("destination"),
                                              ipv4addr
                                            ),
                                            a(str("destination-profile"), arg)
                                        )
                                    ).as(:oneline),
                                    str("location-pool-address"),
                                    str("negotiate-address"),
                                    b(str("dhcp"),
                                        c(
                                            b(str("client-identifier"),
                                                c(
                                                    c(
                                                      a(str("ascii"), arg),
                                                      a(str("hexadecimal"), arg)
                                                    )
                                                )
                                            ).as(:oneline),
                                            a(str("lease-time"), arg),
                                            a(str("retransmission-attempt"), arg),
                                            a(str("retransmission-interval"), arg),
                                            b(str("server-address"),
                                              ipv4addr
                                            ),
                                            str("update-server"),
                                            a(str("vendor-id"), arg)
                                        )
                                    ),
                                    b(str("dhcp-client"),
                                      dhcp_client_type
                                    )
                                )
                            ),
                            b(str("iso"),
                                c(
                                    a(str("address"), arg),
                                    a(str("mtu"), arg)
                                )
                            ),
                            b(str("inet6"),
                                c(
                                    b(str("rpf-check"),
                                        c(
                                            a(str("fail-filter"), arg),
                                            b(str("mode"),
                                                c(
                                                    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("nd6-stale-time"), arg),
                                    str("no-neighbor-learn"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  ca(
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  ca(
                                                      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),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg),
                                            a(str("dialer"), arg)
                                        )
                                    ),
                                    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(a(str("address"), arg),
                                        c(
                                            b(str("destination"),
                                              ipv6addr
                                            ),
                                            str("eui-64"),
                                            str("primary"),
                                            str("preferred"),
                                            str("master-only"),
                                            b(a(str("ndp"), arg),
                                                c(
                                                    b(str("l2-interface"),
                                                      interface_name
                                                    ),
                                                    c(
                                                      b(str("mac"),
                                                        mac_unicaset
                                                      ),
                                                      b(str("multicast-mac"),
                                                        mac_multicast
                                                      )
                                                    ),
                                                    str("publish")
                                                )
                                            ).as(:oneline),
                                            b(str("vrrp-inet6-group"),
                                              vrrp_group
                                            ),
                                            b(str("web-authentication"),
                                                c(
                                                    str("http"),
                                                    str("https"),
                                                    str("redirect-to-https")
                                                )
                                            )
                                        )
                                    ),
                                    str("demux-source"),
                                    str("demux-destination"),
                                    b(str("unnumbered-address"),
                                        c(
                                            b(str("source"),
                                              interface_unit
                                            ),
                                            a(str("preferred-source-address"), arg)
                                        )
                                    ).as(:oneline),
                                    str("dad-disable"),
                                    str("no-dad-disable"),
                                    b(str("dhcpv6-client"),
                                        c(
                                            a(str("client-type"), arg),
                                            a(str("client-ia-type"), str("ia-na") | str("ia-pd")),
                                            str("rapid-commit"),
                                            b(str("update-router-advertisement"),
                                                c(
                                                    a(str("interface"), arg)
                                                )
                                            ),
                                            b(str("client-identifier"),
                                                c(
                                                    a(str("duid-type"), arg)
                                                )
                                            ).as(:oneline),
                                            a(str("req-option"), 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("update-server"),
                                            a(str("retransmission-attempt"), 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)
                                            ),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("group"), arg),
                                            a(str("dialer"), arg)
                                        )
                                    ),
                                    a(str("input-hierarchical-policer"), arg),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("mlppp"),
                                c(
                                    b(str("bundle"),
                                      interface_unit
                                    )
                                )
                            ),
                            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(
                                    b(str("filter"),
                                        c(
                                            c(
                                              a(str("input"), arg),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              a(str("output"), arg),
                                              a(str("output-list"), arg)
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    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
                                            )
                                        )
                                    ),
                                    str("protocols")
                                )
                            ),
                            b(str("vpls"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  ca(
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  ca(
                                                      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),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    )
                                )
                            ),
                            b(str("bridge"),
                                c(
                                    str("core-facing"),
                                    b(str("filter"),
                                        c(
                                            c(
                                              b(str("input"),
                                                  ca(
                                                      a(str("precedence"), arg)
                                                  )
                                              ).as(:oneline),
                                              a(str("input-list"), arg)
                                            ),
                                            c(
                                              b(str("output"),
                                                  ca(
                                                      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),
                                                    a(str("output-precedence"), arg)
                                                )
                                            ),
                                            a(str("group"), arg)
                                        )
                                    ),
                                    b(str("policer"),
                                        c(
                                            a(str("input"), arg),
                                            a(str("output"), arg)
                                        )
                                    ),
                                    a(str("interface-mode"), arg),
                                    a(str("bridge-domain-type"), arg),
                                    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),
                                                c(
                                                    a(str("to-vlan-id"), arg)
                                                )
                                            ).as(:oneline)
                                        )
                                    ),
                                    c(
                                      a(str("isid-list"), arg)
                                    ),
                                    b(str("storm-control"),
                                      storm_control
                                    )
                                )
                            ),
                            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)
                                        )
                                    )
                                )
                            )
                        )
                    ),
                    a(str("service-domain"), arg),
                    str("copy-tos-to-outer-ip-header"),
                    b(str("dialer-options"),
                        c(
                            a(str("pool"), arg),
                            a(str("dial-string"), arg),
                            b(str("incoming-map"),
                                c(
                                    c(
                                      a(str("caller"), arg).as(:oneline),
                                      str("accept-all")
                                    )
                                )
                            ),
                            str("callback"),
                            a(str("callback-wait-period"), arg),
                            a(str("redial-delay"), arg),
                            a(str("idle-timeout"), arg),
                            a(str("watch-list"), arg),
                            a(str("load-threshold"), arg),
                            a(str("load-interval"), arg),
                            a(str("activation-delay"), arg),
                            a(str("deactivation-delay"), arg),
                            a(str("initial-route-check"), arg)
                        )
                    ),
                    b(str("backup-options"),
                        c(
                            b(str("interface"),
                              interface_name
                            )
                        )
                    ),
                    str("dynamic-call-admission-control")
                )
            )
        )
      )
    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_aging_time_config) do
        c(
            c(
              a(str("time"), arg),
              str("unlimited")
            )
        )
    end

    rule(:mac_list) do
      b(arg.as(:arg),
        c(
            b(str("policer"),
                c(
                    a(str("input"), arg),
                    a(str("output"), arg)
                )
            )
        )
      )
    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_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_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"),
              str("range")
            )
        )
    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("snmp"),
              str("snmptrap"),
              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"),
              str("range")
            )
        )
    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("ipv6"),
              str("dstopts"),
              str("routing"),
              str("fragment"),
              str("no-next-header"),
              str("hop-by-hop"),
              str("vrrp"),
              str("range")
            )
        )
    end

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

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

    rule(:mime_list_type) do
      b(arg.as(:arg),
        c(
            a(str("value"), arg)
        )
      )
    end

    rule(:mip_access_type) do
        c(
            c(
              str("wimax"),
              str("generic")
            )
        )
    end

    rule(:mip_home_agent_type) do
        c(
            b(str("virtual-network"),
              mip_virtual_home_agent_address_type
            ),
            a(str("enable-service"), arg),
            a(str("pool-match-order"), str("external-authority") | str("home-agent-address"))
        )
    end

    rule(:mip_peer_type) do
        c(
            b(a(str("ip-address"), arg),
                c(
                    b(str("spi"),
                      spi_type
                    )
                )
            ),
            b(a(str("nai"), arg),
                c(
                    b(str("spi"),
                      spi_type
                    )
                )
            )
        )
    end

    rule(:mip_trace_options_type) do

    end

    rule(:mip_virtual_home_agent_address_type) do
        c(
            b(a(str("home-agent-address"), arg),
                c(
                    a(str("registration-lifetime"), arg),
                    a(str("timestamp-tolerance"), arg),
                    b(str("starting-ip-address"),
                      ipv4addr
                    ),
                    b(str("ending-ip-address"),
                      ipv4addr
                    ),
                    str("revocation-required")
                )
            )
        )
    end

    rule(:mirror_filter_type) do
      b(arg.as(:arg),
        c(
            a(str("protocol"), arg),
            b(str("source-prefix"),
              ipprefix
            ),
            b(str("destination-prefix"),
              ipprefix
            ),
            a(str("source-port"), arg),
            a(str("destination-port"), 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(:monitoring_output_type) do
        c(
            a(str("export-format"), arg),
            a(str("flow-active-timeout"), arg),
            a(str("flow-inactive-timeout"), arg),
            a(str("flow-export-destination"), arg),
            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)
        )
      )
    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"),
            b(a(str("term"), arg),
                c(
                    a(str("filter"), arg),
                    b(str("from"),
                        c(
                            str("ip-version"),
                            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(
                              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"))
                              )
                            )
                        )
                    ),
                    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)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            a(str("count"), arg),
                            str("sample"),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            str("packet-mode"),
                            c(
                              str("accept"),
                              str("discard"),
                              a(str("next"), arg)
                            )
                        )
                    )
                )
            )
        )
      )
    end

    rule(:mpls_ifd_options) do
        c(
            b(str("pop-all-labels"),
                c(
                    a(str("required-depth"), arg)
                )
            )
        )
    end

    rule(:multi_chassis_protection_group) 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"),
                c(
                    a(str("bandwidth-limit"), arg)
                )
            ).as(:oneline),
            b(str("reverse-oif-mapping"),
                c(
                    str("no-qos-adjust")
                )
            ),
            a(str("subscriber-leave-timer"), arg),
            str("no-qos-adjust")
        )
      )
    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("ip-prefix"),
                ipprefix
              ),
              b(str("dns-name"),
                dns_name_type
              ),
              b(str("wildcard-address"),
                wildcard_address_type
              ),
              b(str("range-address"),
                range_address_type
              )
            )
        )
      )
    end

    rule(:dns_name_type) do
      b(arg.as(:arg),
        c(
            str("ipv4-only"),
            str("ipv6-only")
        )
      )
    end

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

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

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

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

    rule(:otn_options_type) do
        c(
            str("laser-enable"),
            str("no-laser-enable"),
            str("line-loopback"),
            str("no-line-loopback"),
            a(str("fec"), arg),
            a(str("rate"), arg),
            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)
                )
            ),
            b(str("trigger"),
                c(
                    b(str("oc-los"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oc-lof"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("oc-lom"),
                        c(
                            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"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-ais"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-bdi"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-iae"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-ttim"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-sd"),
                        c(
                            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"),
                        c(
                            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"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-tca-es"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-tca-ses"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-tca-uas"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("otu-tca-bbe"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-ais"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-bdi"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-oci"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-lck"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-ttim"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-sd"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-tca-es"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-tca-ses"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-tca-uas"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("odu-tca-bbe"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("opu-ptim"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline)
                )
            )
        )
    end

    rule(:override_local_server_type) do
        c(
            a(str("interface-client-limit"), arg),
            str("no-arp"),
            str("client-discover-match").as(:oneline),
            b(str("process-inform"),
                c(
                    a(str("pool"), arg)
                )
            )
        )
    end

    rule(:override_type) do
        c(
            str("allow-snooped-clients"),
            str("no-allow-snooped-clients"),
            str("always-write-giaddr"),
            str("always-write-option-82"),
            str("layer2-unicast-replies"),
            str("trust-option-82"),
            str("disable-relay"),
            str("no-bind-on-request"),
            a(str("interface-client-limit"), arg),
            str("no-arp"),
            str("passive-client-processing"),
            str("client-discover-match").as(:oneline),
            str("proxy-mode"),
            str("replace-ip-source-with").as(:oneline),
            str("send-release-on-delete")
        )
    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("version"), arg),
            a(str("autonomous-system-type"), arg),
            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
            )
        )
      )
    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("liveness-detection"),
                c(
                    a(str("version"), arg),
                    a(str("minimum-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(:periodic_oam) do
        c(
            str("mpls-tp-mode"),
            b(str("bfd-liveness-detection"),
                c(
                    a(str("version"), arg),
                    a(str("minimum-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"),
                        c(
                            c(
                              str("teardown"),
                              b(str("make-before-break"),
                                  c(
                                      a(str("teardown-timeout"), arg)
                                  )
                              )
                            )
                        )
                    ).as(:oneline)
                )
            ),
            a(str("lsp-ping-interval"), arg),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sca(
                            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"), str("configuration") | str("pipe") | str("rpc-packet-details") | str("database") | str("network") | str("traceroute") | str("all")).as(:oneline)
                )
            )
        )
    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_dense_group_type) do
      b(arg.as(:arg),
        c(
            c(
              str("reject"),
              str("announce")
            )
        )
      ).as(:oneline)
    end

    rule(:pim_filter_obj) do
        c(
            a(str("match-on"), arg),
            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_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"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), str("events") | str("heartbeat") | str("process-tracking") | str("ui") | str("all")).as(:oneline)
        )
    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") | str("address"))
                      )
                    ),
                    c(
                      b(str("destination-address"),
                            (str("any") | str("any-ipv4") | str("any-ipv6") | str("address"))
                      )
                    ),
                    str("source-address-excluded"),
                    str("destination-address-excluded"),
                    c(
                      a(str("application"), arg)
                    ),
                    c(
                      b(str("source-identity"),
                            (str("any") | str("authenticated-user") | str("unauthenticated-user") | str("unknown-user") | arg)
                      )
                    ),
                    c(
                      b(str("from-zone"),
                            (str("any") | str("from-zone-name"))
                      )
                    ),
                    c(
                      b(str("to-zone"),
                            (str("any") | str("to-zone-name"))
                      )
                    )
                )
            ),
            b(str("then"),
                c(
                    c(
                      str("deny"),
                      str("reject"),
                      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")
                                  )
                              ),
                              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"),
            str("ssl-proxy"),
            b(str("uac-policy"),
                c(
                    a(str("captive-portal"), arg)
                )
            ),
            a(str("utm-policy"), 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")
            )
        )
    end

    rule(:count_type) do
        c(
            b(str("alarm"),
                c(
                    a(str("per-second-threshold"), arg),
                    a(str("per-minute-threshold"), arg)
                )
            ).as(:oneline)
        )
    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)
                  )
              ),
              b(str("web-authentication"),
                  c(
                      a(str("client-match"), arg)
                  )
              ),
              b(str("user-firewall"),
                  c(
                      a(str("access-profile"), arg),
                      a(str("ssl-termination-profile"), arg),
                      a(str("domain"), arg)
                  )
              )
            )
        )
    end

    rule(:jsf_application_traffic_control_rule_set_type) do
        c(
            a(str("rule-set"), arg)
        )
    end

    rule(:jsf_service_rule_set_type) do
        c(
            a(str("rule-set"), arg)
        )
    end

    rule(:log_type) do
        c(
            str("session-init"),
            str("session-close")
        )
    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"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), 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("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("compression"),
                c(
                    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)
        )
    end

    rule(:pppoe_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), 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("timer") | str("ui") | str("all")).as(:oneline)
        )
    end

    rule(:pppoe_options_type) do
        c(
            a(str("underlying-interface"), 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")
            )
        )
    end

    rule(:pppoe_underlying_options_type) do
        c(
            a(str("access-concentrator"), arg),
            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)
                )
            )
        )
    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("accounting-port"), arg),
            b(str("secret"),
              unreadable
            ),
            a(str("timeout"), arg),
            a(str("retry"), arg),
            a(str("max-outstanding-requests"), arg),
            b(str("source-address"),
              ipaddr
            ),
            a(str("routing-instance"), 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),
                            a(str("over-limit"), arg)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:proto_object) do
      b(arg.as(:arg),
        c(
            b(str("tunable-name"),
              tunable_object
            )
        )
      )
    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_unicaset
            ),
            b(str("bfd-liveness-detection"),
                c(
                    a(str("version"), arg),
                    a(str("minimum-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),
                            a(str("algorithm"), arg),
                            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"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), 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("port"), arg),
            a(str("accounting-port"), arg),
            b(str("secret"),
              unreadable
            ),
            a(str("timeout"), arg),
            a(str("retry"), arg),
            a(str("max-outstanding-requests"), arg),
            b(str("source-address"),
              ipaddr
            )
        )
      )
    end

    rule(:range_address_type) do
      b(arg.as(:arg),
        c(
            b(str("to"),
                c(
                    b(str("range-high"),
                      ipv4addr
                    )
                )
            )
        )
      )
    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
            )
        )
    end

    rule(:relay_option_60_type_group) do
        c(
            b(str("vendor-option"),
                c(
                    b(str("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")
                    )
                )
            )
        )
    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")
                    )
                )
            ),
            b(a(str("hexadecimal"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      a(str("local-server-group"), arg),
                      str("drop")
                    )
                )
            )
        )
    end

    rule(:relay_option_60_type_top) do
        c(
            b(str("vendor-option"),
                c(
                    b(str("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")
                    )
                )
            )
        )
    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")
                    )
                )
            ),
            b(a(str("hexadecimal"), arg),
                c(
                    c(
                      a(str("relay-server-group"), arg),
                      a(str("local-server-group"), arg),
                      str("drop")
                    )
                )
            )
        )
    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")
                        )
                    ),
                    a(str("use-interface-description"), arg)
                )
            )
        )
    end

    rule(:res_cleanupd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), str("events") | str("gencfg") | str("module") | str("sysvsem") | str("sysvshm") | str("tracking") | str("ui") | 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"),
                      ca(
                            a(str("origin"), arg),
                            str("atomic-aggregate"),
                            b(str("aggregator"),
                                ca(
                                    b(str("address"),
                                      ipv4addr
                                    )
                                )
                            )
                        )
                    ),
                    str("discard"),
                    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"),
                      ca(
                            a(str("origin"), arg),
                            str("atomic-aggregate"),
                            b(str("aggregator"),
                                ca(
                                    b(str("address"),
                                      ipv4addr
                                    )
                                )
                            )
                        )
                    ),
                    str("discard"),
                    c(
                      str("brief"),
                      str("full")
                    ),
                    c(
                      str("active"),
                      str("passive")
                    )
                )
            )
        )
    end

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

    rule(:rib_group_type) do
        c(
            a(str("inet"), arg),
            a(str("inet6"), arg)
        )
    end

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

    rule(:rip_filter_obj) do
        c(
            a(str("match-on"), arg),
            b(str("policy"),
              policy_algebra
            )
        ).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(: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("autonomous-system-type"), arg),
            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_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_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"),
                c(
                    c(
                      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("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("autonomous-system-type"), arg),
            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
                        )
                    )
                )
            ),
            a(str("version"), arg)
        )
      )
    end

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

    rule(:sbc_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    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(
                    a(str("configuration"), arg),
                    a(str("ipc"), arg),
                    a(str("device-monitor"), arg),
                    a(str("ui"), arg),
                    a(str("common"), arg),
                    a(str("memory-pool"), arg),
                    a(str("packet-capture"), arg),
                    a(str("all"), arg)
                )
            )
        )
    end

    rule(:sbl_type) do
        c(
            b(a(str("profile"), arg),
                c(
                    str("sbl-default-server"),
                    str("no-sbl-default-server"),
                    a(str("spam-action"), arg),
                    a(str("custom-tag-string"), arg)
                )
            )
        )
    end

    rule(:scheduler_object_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("start-date"),
                s(
                  a(str("start-date"), arg),
                  a(str("stop-date"), arg)
                )
            ),
            b(str("daily"),
              daily_object
            ),
            b(str("sunday"),
              daily_object
            ),
            b(str("monday"),
              daily_object
            ),
            b(str("tuesday"),
              daily_object
            ),
            b(str("wednesday"),
              daily_object
            ),
            b(str("thursday"),
              daily_object
            ),
            b(str("friday"),
              daily_object
            ),
            b(str("saturday"),
              daily_object
            )
        )
      )
    end

    rule(:daily_object) do
        c(
            c(
              b(str("start-time"),
                  s(
                    a(str("start-time-value"), arg),
                    a(str("stop-time"), arg)
                  )
              ),
              str("exclude"),
              str("all-day")
            )
        )
    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),
                    str("direct-access"),
                    b(str("file"),
                      commit_scripts_file_type
                    )
                )
            ),
            b(str("op"),
                c(
                    b(str("traceoptions"),
                      script_traceoptions
                    ),
                    b(str("file"),
                      op_scripts_file_type
                    ),
                    str("refresh"),
                    a(str("refresh-from"), arg),
                    str("no-allow-url")
                )
            ),
            str("load-scripts-from-flash")
        )
    end

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

    rule(:op_scripts_file_type) do
      b(arg.as(:arg),
        c(
            a(str("command"), arg),
            a(str("description"), quote | arg),
            a(str("source"), arg),
            str("refresh"),
            a(str("refresh-from"), arg),
            b(a(str("arguments"), arg),
                c(
                    a(str("description"), quote | arg)
                )
            ),
            b(str("checksum"),
                c(
                    a(str("md5"), arg),
                    a(str("sha1"), arg),
                    a(str("sha-256"), arg)
                )
            )
        )
      )
    end

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

    rule(:securid_server_object) do
      b(arg.as(:arg),
        c(
            a(str("configuration-file"), arg)
        )
      )
    end

    rule(:security_group_vpn) do
        c(
            b(str("member"),
              gvpn_member
            ),
            b(str("server"),
              gvpn_server
            ),
            str("co-location")
        )
    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("proposal"),
              gvpn_member_ike_proposal
            ),
            b(str("policy"),
              gvpn_member_ike_policy
            ),
            b(a(str("gateway"), arg),
                c(
                    a(str("ike-policy"), arg),
                    c(
                      b(str("address"),
                        hostname
                      )
                    ),
                    b(str("local-identity"),
                        c(
                            c(
                              b(str("inet"),
                                  c(
                                      b(str("identity-ipv4"),
                                        ipv4addr
                                      )
                                  )
                              ),
                              b(str("hostname"),
                                  c(
                                      a(str("identity-hostname"), arg)
                                  )
                              ),
                              b(str("user-at-hostname"),
                                  c(
                                      a(str("identity-user"), arg)
                                  )
                              ),
                              str("distinguished-name")
                            )
                        )
                    ).as(:oneline),
                    b(str("local-address"),
                      ipv4addr
                    )
                )
            )
        )
    end

    rule(:gvpn_member_ike_policy) do
      b(arg.as(:arg),
        c(
            a(str("mode"), arg),
            a(str("description"), quote | arg),
            a(str("proposals"), arg),
            b(str("certificate"),
                c(
                    a(str("local-certificate"), arg),
                    a(str("peer-certificate-type"), arg)
                )
            ),
            a(str("proposal-set"), arg),
            b(str("pre-shared-key"),
                c(
                    c(
                      b(str("ascii-text"),
                        unreadable
                      ),
                      b(str("hexadecimal"),
                        unreadable
                      )
                    )
                )
            ).as(:oneline)
        )
      )
    end

    rule(:gvpn_member_ike_proposal) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("authentication-method"), arg),
            a(str("dh-group"), arg),
            a(str("authentication-algorithm"), arg),
            a(str("encryption-algorithm"), arg),
            a(str("lifetime-seconds"), arg)
        )
      )
    end

    rule(:gvpn_member_ipsec_vpn) do
        c(
            b(str("vpn"),
              ipsec_gvpn_member_template
            )
        )
    end

    rule(:gvpn_server) do
        c(
            b(str("traceoptions"),
              gvpn_server_traceoptions
            ),
            b(str("ike"),
              gvpn_server_ike
            ),
            b(str("ipsec"),
              gvpn_server_ipsec_vpn
            ),
            b(str("group"),
              gvpn_server_group_template
            )
        )
    end

    rule(:gvpn_server_group_template) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("group-id"), arg),
            b(str("ike-gateway"),
              gvpn_server_ike_gateway
            ),
            a(str("activation-time-delay"), arg),
            c(
              a(str("anti-replay-time-window"), arg),
              str("no-anti-replay")
            ),
            b(str("server-address"),
              ipv4addr
            ),
            b(str("server-member-communication"),
              gvpn_server_member_communication
            ),
            b(str("ipsec-sa"),
              gvpn_server_group_ipsecsa
            )
        )
      )
    end

    rule(:gvpn_server_group_ipsecsa) do
      b(arg.as(:arg),
        c(
            a(str("proposal"), arg),
            b(str("match-policy"),
              gvpn_server_group_ipsecsa_match
            )
        )
      )
    end

    rule(:gvpn_server_group_ipsecsa_match) do
      b(arg.as(:arg),
        c(
            b(str("source"),
              ipv4prefix_mandatory
            ),
            b(str("destination"),
              ipv4prefix_mandatory
            ),
            a(str("source-port"), arg),
            a(str("destination-port"), arg),
            a(str("protocol"), arg)
        )
      )
    end

    rule(:gvpn_server_ike) do
        c(
            b(str("proposal"),
              gvpn_server_ike_proposal
            ),
            b(str("policy"),
              ike_policy
            ),
            b(a(str("gateway"), arg),
                c(
                    a(str("ike-policy"), arg),
                    c(
                      a(str("address"), arg),
                      b(str("dynamic"),
                          c(
                              c(
                                b(str("distinguished-name"),
                                    c(
                                        a(str("container"), arg),
                                        a(str("wildcard"), arg)
                                    )
                                ),
                                a(str("hostname"), arg),
                                b(str("inet"),
                                  ipv4addr
                                ),
                                a(str("user-at-hostname"), arg)
                              )
                          )
                      )
                    ),
                    b(str("local-identity"),
                        c(
                            c(
                              b(str("inet"),
                                  c(
                                      b(str("identity-ipv4"),
                                        ipv4addr
                                      )
                                  )
                              ),
                              b(str("hostname"),
                                  c(
                                      a(str("identity-hostname"), arg)
                                  )
                              ),
                              b(str("user-at-hostname"),
                                  c(
                                      a(str("identity-user"), arg)
                                  )
                              ),
                              str("distinguished-name")
                            )
                        )
                    ).as(:oneline)
                )
            )
        )
    end

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

    rule(:gvpn_server_ike_proposal) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("authentication-method"), arg),
            a(str("dh-group"), arg),
            a(str("authentication-algorithm"), arg),
            a(str("encryption-algorithm"), arg)
        )
      )
    end

    rule(:gvpn_server_ipsec_vpn) do
        c(
            b(str("proposal"),
              gvpn_server_ipsec_proposal
            )
        )
    end

    rule(:gvpn_server_ipsec_proposal) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("authentication-algorithm"), arg),
            a(str("encryption-algorithm"), arg),
            a(str("lifetime-seconds"), arg)
        )
      )
    end

    rule(:gvpn_server_member_communication) do
        c(
            a(str("communication-type"), arg),
            b(str("multicast-group"),
              ipv4addr
            ),
            b(str("multicast-outgoing-interface"),
              gvpn_server_multicast_interface
            ),
            a(str("lifetime-seconds"), arg),
            a(str("retransmission-period"), arg),
            a(str("number-of-retransmission"), arg),
            a(str("heartbeat"), arg),
            a(str("encryption-algorithm"), arg),
            a(str("sig-hash-algorithm"), arg),
            a(str("certificate"), arg)
        )
    end

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

    rule(:gvpn_server_traceoptions) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    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"), 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)
        )
    end

    rule(:ike_policy) do
      b(arg.as(:arg),
        c(
            a(str("mode"), arg),
            a(str("description"), quote | arg),
            a(str("proposals"), arg),
            b(str("certificate"),
                c(
                    a(str("local-certificate"), arg),
                    a(str("peer-certificate-type"), arg)
                )
            ),
            a(str("proposal-set"), arg),
            b(str("pre-shared-key"),
                c(
                    c(
                      b(str("ascii-text"),
                        unreadable
                      ),
                      b(str("hexadecimal"),
                        unreadable
                      )
                    )
                )
            ).as(:oneline)
        )
      )
    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)
        )
      )
    end

    rule(:security_ike) do
        c(
            b(str("traceoptions"),
              security_traceoptions
            ),
            b(str("respond-bad-spi"),
                c(
                    a(str("max-responses"), 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(
                      a(str("address"), arg),
                      b(str("dynamic"),
                          c(
                              c(
                                b(str("distinguished-name"),
                                    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),
                              a(str("ike-user-type"), arg)
                          )
                      )
                    ),
                    b(str("dead-peer-detection"),
                        c(
                            c(
                              str("optimized"),
                              str("probe-idle-tunnel"),
                              str("always-send")
                            ),
                            a(str("interval"), arg),
                            a(str("threshold"), arg)
                        )
                    ),
                    str("no-nat-traversal"),
                    a(str("nat-keepalive"), arg),
                    b(str("local-identity"),
                        c(
                            c(
                              b(str("inet"),
                                  c(
                                      b(str("identity-ipv4"),
                                        ipv4addr
                                      )
                                  )
                              ),
                              b(str("inet6"),
                                  c(
                                      b(str("identity-ipv6"),
                                        ipv6addr
                                      )
                                  )
                              ),
                              b(str("hostname"),
                                  c(
                                      a(str("identity-hostname"), arg)
                                  )
                              ),
                              b(str("user-at-hostname"),
                                  c(
                                      a(str("identity-user"), arg)
                                  )
                              ),
                              str("distinguished-name")
                            )
                        )
                    ).as(:oneline),
                    b(str("remote-identity"),
                        c(
                            c(
                              b(str("inet"),
                                  c(
                                      b(str("identity-ipv4"),
                                        ipv4addr
                                      )
                                  )
                              ),
                              b(str("inet6"),
                                  c(
                                      b(str("identity-ipv6"),
                                        ipv6addr
                                      )
                                  )
                              ),
                              b(str("hostname"),
                                  c(
                                      a(str("identity-hostname"), arg)
                                  )
                              ),
                              b(str("user-at-hostname"),
                                  c(
                                      a(str("identity-user"), arg)
                                  )
                              ),
                              b(str("distinguished-name"),
                                  c(
                                      a(str("container"), arg),
                                      a(str("wildcard"), arg)
                                  )
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("external-interface"),
                      interface_unit
                    ),
                    b(str("local-address"),
                      ipaddr
                    ),
                    b(str("xauth"),
                        c(
                            a(str("access-profile"), arg)
                        )
                    ).as(:oneline),
                    str("general-ikeid"),
                    a(str("version"), arg)
                )
            )
        )
    end

    rule(:ike_proposal) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("authentication-method"), arg),
            a(str("dh-group"), arg),
            a(str("authentication-algorithm"), arg),
            a(str("encryption-algorithm"), arg),
            a(str("lifetime-seconds"), arg)
        )
      )
    end

    rule(:security_ipsec_vpn) do
        c(
            b(str("internal"),
                c(
                    b(str("security-association"),
                      ipsec_internal_sa
                    )
                )
            ),
            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
            )
        )
    end

    rule(:ipsec_internal_sa) do
        c(
            b(str("manual"),
                c(
                    b(str("encryption"),
                        c(
                            a(str("algorithm"), arg),
                            a(str("ike-ha-link-encryption"), arg),
                            b(str("key"),
                                c(
                                    c(
                                      b(str("ascii-text"),
                                        unreadable
                                      )
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
    end

    rule(:ipsec_policy) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("perfect-forward-secrecy"),
                c(
                    a(str("keys"), arg)
                )
            ),
            a(str("proposals"), arg),
            a(str("proposal-set"), arg)
        )
      )
    end

    rule(:ipsec_proposal) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("protocol"), arg),
            a(str("authentication-algorithm"), arg),
            a(str("encryption-algorithm"), arg),
            a(str("lifetime-seconds"), arg),
            a(str("lifetime-kilobytes"), arg)
        )
      )
    end

    rule(:ipsec_sa) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            a(str("mode"), arg),
            c(
              b(str("manual"),
                security_association_manual
              )
            )
        )
      )
    end

    rule(:ipsec_traceoptions) do
        c(
            a(str("flag"), 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
            ),
            a(str("df-bit"), arg),
            b(str("vpn-monitor"),
              ipsec_template_monitor
            ),
            c(
              b(str("manual"),
                  c(
                      b(str("gateway"),
                        hostname
                      ),
                      b(str("external-interface"),
                        interface_unit
                      ),
                      a(str("protocol"), arg),
                      a(str("spi"), arg),
                      b(str("authentication"),
                          c(
                              a(str("algorithm"), arg),
                              b(str("key"),
                                  c(
                                      c(
                                        b(str("ascii-text"),
                                          unreadable
                                        ),
                                        b(str("hexadecimal"),
                                          unreadable
                                        )
                                      )
                                  )
                              ).as(:oneline)
                          )
                      ),
                      b(str("encryption"),
                          c(
                              a(str("algorithm"), arg),
                              b(str("key"),
                                  c(
                                      c(
                                        b(str("ascii-text"),
                                          unreadable
                                        ),
                                        b(str("hexadecimal"),
                                          unreadable
                                        )
                                      )
                                  )
                              ).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
                    )
                )
            ),
            a(str("establish-tunnels"), arg)
        )
      )
    end

    rule(:ipsec_template_monitor) do
        c(
            str("optimized"),
            b(str("source-interface"),
              interface_unit
            ),
            b(str("destination-ip"),
              ipaddr
            )
        )
    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_association_manual) do
        c(
            a(str("direction"), str("bidirectional"),
                c(
                    a(str("protocol"), arg),
                    a(str("spi"), arg),
                    b(str("authentication"),
                        c(
                            a(str("algorithm"), arg),
                            b(str("key"),
                                c(
                                    c(
                                      b(str("ascii-text"),
                                        unreadable
                                      ),
                                      b(str("hexadecimal"),
                                        unreadable
                                      )
                                    )
                                )
                            ).as(:oneline)
                        )
                    ),
                    b(str("encryption"),
                        c(
                            a(str("algorithm"), arg),
                            b(str("key"),
                                c(
                                    c(
                                      b(str("ascii-text"),
                                        unreadable
                                      ),
                                      b(str("hexadecimal"),
                                        unreadable
                                      )
                                    )
                                )
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
    end

    rule(:security_model_access) do
      b((str("any") | str("usm") | str("v1") | str("v2c")).as(:arg),
        c(
            a(str("security-level"), str("none") | str("authentication") | str("privacy"),
                c(
                    a(str("context-match"), arg),
                    a(str("read-view"), arg),
                    a(str("write-view"), arg),
                    a(str("notify-view"), arg)
                )
            )
        )
      )
    end

    rule(:security_pki) do
        c(
            b(a(str("ca-profile"), arg),
                c(
                    a(str("ca-identity"), 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),
                                    a(str("nonce-payload"), arg),
                                    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"),
                                        c(
                                            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(str("auto-re-enrollment"),
                c(
                    b(a(str("certificate-id"), arg),
                        c(
                            a(str("ca-profile-name"), arg),
                            b(str("challenge-password"),
                              unreadable
                            ),
                            a(str("re-enroll-trigger-time-percentage"), arg),
                            str("re-generate-keypair"),
                            b(str("scep-encryption-algorithm"),
                                c(
                                    c(
                                      str("des"),
                                      str("des3")
                                    )
                                )
                            ),
                            b(str("scep-digest-algorithm"),
                                c(
                                    c(
                                      str("md5"),
                                      str("sha1")
                                    )
                                )
                            )
                        )
                    )
                )
            ),
            b(str("traceoptions"),
                c(
                    str("no-remote-trace"),
                    b(str("file"),
                        sca(
                            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"), 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"),
                sca(
                    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),
            str("filter"),
            a(str("flag"), 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)
        )
    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")
        )
      )
    end

    rule(:address_book_type) do
        c(
            b(str("address"),
              address_type
            ),
            b(str("address-set"),
              address_set_type
            )
        )
    end

    rule(:server_group_type) do
        c(
            b(a(str("server-group"), arg),
                c(
                    a(str("address"), 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_set_syslog_object) do
        c(
            b(a(str("host"), arg),
                c(
                    a(str("contents"), str("services"),
                        c(
                            c(
                              str("any"),
                              str("emergency"),
                              str("alert"),
                              str("critical"),
                              str("error"),
                              str("warning"),
                              str("notice"),
                              str("info"),
                              str("none")
                            )
                        )
                    ).as(:oneline),
                    a(str("facility-override"), arg),
                    a(str("log-prefix"), arg),
                    a(str("port"), arg),
                    b(str("class"),
                        c(
                            b(str("session-logs"),
                                c(
                                    str("open"),
                                    str("close")
                                )
                            ).as(:oneline),
                            str("packet-logs"),
                            str("stateful-firewall-logs"),
                            str("alg-logs"),
                            str("nat-logs"),
                            str("ids-logs")
                        )
                    )
                )
            ),
            a(str("message-rate-limit"), arg)
        )
    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")
        )
    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"),
                sca(
                    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"), 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"),
                sca(
                    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"), str("sdb") | str("general") | str("ui") | str("snmp") | str("all")).as(:oneline)
        )
    end

    rule(:softwire_option_type) do
      b(arg.as(:arg),
        c(
            b(str("softwire-concentrator"),
              ipv6addr
            ),
            a(str("softwire-type"), arg)
        )
      )
    end

    rule(:sonet_options_type) do
        c(
            a(str("vtmapping"), arg),
            a(str("fcs"), arg),
            a(str("path-trace"), arg),
            a(str("loopback"), arg),
            b(str("trigger"),
                c(
                    b(str("lol"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("pll"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("lof"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("los"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("ais-l"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("rfi-l"),
                        c(
                            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"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("lop-p"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("rfi-p"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("uneq-p"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("plm-p"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("locd"),
                        c(
                            c(
                              str("ignore"),
                              b(str("hold-time"),
                                  sc(
                                      a(str("up"), arg),
                                      a(str("down"), arg)
                                  )
                              ).as(:oneline)
                            )
                        )
                    ).as(:oneline),
                    b(str("lcdp"),
                        c(
                            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(
              str("payload-scrambler").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(:sophos_fallback_settings) do
        c(
            a(str("default"), arg),
            a(str("content-size"), arg),
            a(str("engine-not-ready"), arg),
            a(str("timeout"), arg),
            a(str("out-of-resources"), arg),
            a(str("too-many-requests"), arg)
        )
    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(:source_class_name_object) do
      arg.as(:arg).as(:oneline)
    end

    rule(:spi_type) do
      b(arg.as(:arg),
        c(
            b(str("entity-type"),
              peer_entity_type
            ),
            b(str("algorithm"),
              peer_algorithm_type
            ),
            b(str("key"),
              peer_key_type
            ),
            b(str("replay-method"),
                c(
                    c(
                      b(str("timestamp"),
                          c(
                              a(str("seconds"), arg)
                          )
                      ),
                      str("none")
                    )
                )
            ).as(:oneline)
        )
      )
    end

    rule(:peer_algorithm_type) do
        c(
            c(
              str("hmac-md5"),
              str("md5")
            )
        ).as(:oneline)
    end

    rule(:peer_entity_type) do
        c(
            c(
              str("host"),
              str("mobility-agent")
            )
        ).as(:oneline)
    end

    rule(:peer_key_type) do
        c(
            c(
              b(str("hex"),
                  c(
                      a(str("hex-value"), arg)
                  )
              ),
              b(str("ascii"),
                  c(
                      a(str("ascii-value"), arg)
                  )
              )
            )
        ).as(:oneline)
    end

    rule(:ssd_traceoptions_type) do
        c(
            str("no-remote-trace"),
            b(str("file"),
                sca(
                    a(str("size"), arg),
                    a(str("files"), arg),
                    str("world-readable"),
                    str("no-world-readable"),
                    b(str("match"),
                      regular_expression
                    )
                )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), str("ssd-infrastructure") | str("ssd-server") | str("client-management") | str("route-management") | str("nexthop-management") | str("all")).as(:oneline)
        )
    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"),
                              a(str("ri-name"), arg)
                            )
                        )
                    ),
                    b(str("address"),
                        c(
                            b(str("ipaddr"),
                              ipprefix
                            ),
                            c(
                              b(str("to"),
                                  c(
                                      b(str("ipaddr"),
                                        ipprefix
                                      )
                                  )
                              ),
                              a(str("port"), arg)
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(a(str("rule-set"), arg),
                c(
                    a(str("description"), quote | arg),
                    b(str("from"),
                        c(
                            c(
                              b(str("routing-instance"),
                                    (str("default") | str("routing-instance-name"))
                              ),
                              a(str("zone"), arg),
                              b(str("interface"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("rule"),
                      dest_nat_rule_object
                    )
                )
            )
        )
    end

    rule(:dest_nat_rule_object) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            b(str("dest-nat-rule-match"),
                c(
                    b(str("source-address"),
                      ipprefix
                    ),
                    a(str("source-address-name"), arg),
                    c(
                      b(str("destination-address"),
                          c(
                              b(str("dst-addr"),
                                ipprefix
                              )
                          )
                      ).as(:oneline),
                      b(str("destination-address-name"),
                          c(
                              a(str("dst-addr-name"), arg)
                          )
                      ).as(:oneline)
                    ),
                    b(a(str("destination-port"), arg),
                        c(
                            b(str("to"),
                                c(
                                    a(str("high"), arg)
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("protocol"),
                          (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(
                                      a(str("pool-name"), 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),
                c(
                    b(str("to"),
                        c(
                            b(str("ipaddr"),
                              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),
                c(
                    b(str("to"),
                        c(
                            b(str("ipv6addr"),
                              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(
                            a(str("ri-name"), arg)
                        )
                    ),
                    b(a(str("address"), arg),
                        c(
                            b(str("to"),
                                c(
                                    b(str("ipaddr"),
                                      ipprefix
                                    )
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("host-address-base"),
                        c(
                            b(str("ipaddr"),
                              ipprefix
                            )
                        )
                    ).as(:oneline),
                    b(str("port"),
                        c(
                            c(
                              str("no-translation"),
                              b(str("range"),
                                  c(
                                      a(str("low"), arg),
                                      b(str("to"),
                                          c(
                                              a(str("high"), arg)
                                          )
                                      ),
                                      b(str("twin-port"),
                                          c(
                                              a(str("low"), arg),
                                              b(str("to"),
                                                  c(
                                                      a(str("high"), arg)
                                                  )
                                              )
                                          )
                                      )
                                  )
                              ),
                              a(str("port-overloading-factor"), arg)
                            ),
                            b(str("block-allocation"),
                              block_allocation_object
                            ),
                            b(str("deterministic"),
                              deterministic_object
                            )
                        )
                    ),
                    b(str("overflow-pool"),
                        c(
                            c(
                              a(str("pool-name"), arg),
                              str("interface")
                            )
                        )
                    ).as(:oneline),
                    str("address-shared"),
                    b(str("address-pooling"),
                        c(
                            c(
                              str("paired"),
                              str("no-paired")
                            )
                        )
                    ).as(:oneline),
                    b(str("address-persistent"),
                        c(
                            b(str("subscriber"),
                                c(
                                    a(str("ipv6-prefix-length"), arg)
                                )
                            ).as(:oneline)
                        )
                    ).as(:oneline),
                    b(str("pool-utilization-alarm"),
                      source_nat_pool_utilization_alarm_object
                    ).as(:oneline)
                )
            ),
            str("address-persistent"),
            b(str("pool-utilization-alarm"),
              source_nat_pool_utilization_alarm_object
            ).as(:oneline),
            b(str("port-randomization"),
                c(
                    c(
                      str("disable")
                    )
                )
            ).as(:oneline),
            b(str("pool-default-port-range"),
                c(
                    a(str("low"), arg),
                    b(str("to"),
                        c(
                            a(str("high"), arg)
                        )
                    )
                )
            ).as(:oneline),
            b(str("pool-default-twin-port-range"),
                c(
                    a(str("low"), arg),
                    b(str("to"),
                        c(
                            a(str("high"), arg)
                        )
                    )
                )
            ).as(:oneline),
            b(str("interface"),
                c(
                    c(
                      b(str("port-overloading"),
                          c(
                              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"),
                        c(
                            c(
                              b(str("routing-instance"),
                                    (str("default") | str("routing-instance-name"))
                              ),
                              a(str("zone"), arg),
                              b(str("interface"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("to"),
                        c(
                            c(
                              b(str("routing-instance"),
                                    (str("default") | str("routing-instance-name"))
                              ),
                              a(str("zone"), arg),
                              b(str("interface"),
                                interface_name
                              )
                            )
                        )
                    ).as(:oneline),
                    b(str("rule"),
                      src_nat_rule_object
                    )
                )
            )
        )
    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),
            b(str("log"),
                c(
                    c(
                      str("disable")
                    )
                )
            ).as(:oneline)
        )
    end

    rule(:deterministic_object) do
        c(
            a(str("block-size"), arg),
            b(str("host"),
                c(
                    b(str("address"),
                      ipprefix
                    ),
                    a(str("address-name"), arg)
                )
            ).as(:oneline)
        )
    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("src-nat-rule-match"),
                c(
                    b(str("source-address"),
                      ipprefix
                    ),
                    a(str("source-address-name"), arg),
                    b(a(str("source-port"), arg),
                        c(
                            b(str("to"),
                                c(
                                    a(str("high"), arg)
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("destination-address"),
                      ipprefix
                    ),
                    a(str("destination-address-name"), arg),
                    b(a(str("destination-port"), arg),
                        c(
                            b(str("to"),
                                c(
                                    a(str("high"), arg)
                                )
                            )
                        )
                    ).as(:oneline),
                    b(str("protocol"),
                          (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"),
                                  c(
                                      a(str("pool-name"), arg),
                                      b(str("persistent-nat"),
                                        persistent_nat_object
                                      )
                                  )
                              ),
                              b(str("interface"),
                                  c(
                                      b(str("persistent-nat"),
                                        persistent_nat_object
                                      )
                                  )
                              )
                            ),
                            b(str("rule-session-count-alarm"),
                              nat_rule_session_count_alarm_object
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:persistent_nat_object) do
        c(
            b(str("permit"),
                c(
                    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"),
                        c(
                            c(
                              b(str("routing-instance"),
                                    (str("default") | str("routing-instance-name"))
                              ),
                              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("static-nat-rule-match"),
                c(
                    b(str("source-address"),
                      ipprefix
                    ),
                    a(str("source-address-name"), arg),
                    b(a(str("source-port"), arg),
                        c(
                            b(str("to"),
                                c(
                                    a(str("high"), arg)
                                )
                            )
                        )
                    ).as(:oneline),
                    c(
                      b(str("destination-address"),
                          c(
                              b(str("dst-addr"),
                                ipprefix
                              )
                          )
                      ).as(:oneline),
                      b(str("destination-address-name"),
                          c(
                              a(str("dst-addr-name"), arg)
                          )
                      ).as(:oneline)
                    ),
                    b(str("destination-port"),
                        c(
                            a(str("low"), arg),
                            b(str("to"),
                                c(
                                    a(str("high"), arg)
                                )
                            )
                        )
                    ).as(:oneline)
                )
            ),
            b(str("then"),
                c(
                    b(str("static-nat"),
                        c(
                            c(
                              b(str("inet"),
                                  c(
                                      a(str("routing-instance"), arg)
                                  )
                              ),
                              b(str("prefix"),
                                  c(
                                      b(str("addr-prefix"),
                                        ipprefix
                                      ),
                                      b(str("mapped-port"),
                                        static_nat_rule_mapped_port_object
                                      ).as(:oneline),
                                      a(str("routing-instance"), arg)
                                  )
                              ),
                              b(str("prefix-name"),
                                  c(
                                      a(str("addr-prefix-name"), arg),
                                      b(str("mapped-port"),
                                        static_nat_rule_mapped_port_object
                                      ).as(:oneline),
                                      a(str("routing-instance"), arg)
                                  )
                              )
                            ),
                            b(str("rule-session-count-alarm"),
                              nat_rule_session_count_alarm_object
                            ).as(:oneline)
                        )
                    )
                )
            )
        )
      )
    end

    rule(:static_nat_rule_mapped_port_object) do
        c(
            a(str("low"), arg),
            b(str("to"),
                c(
                    a(str("high"), arg)
                )
            )
        ).as(:oneline)
    end

    rule(:stp_trace_options_esp) do
        c(
            b(str("file"),
              esp_trace_file_type
            ),
            a(str("flag"), 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"),
                c(
                    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(:syslog_object) do
      b((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(:tacplus_server_object) do
      b(arg.as(:arg),
        c(
            a(str("port"), arg),
            b(str("secret"),
              unreadable
            ),
            a(str("timeout"), arg),
            str("single-connection"),
            b(str("source-address"),
              ipv4addr
            )
        )
      )
    end

    rule(:te_class_object) do
        c(
            a(str("traffic-class"), arg),
            a(str("priority"), arg)
        ).as(:oneline)
    end

    rule(:term_object) do
      b(arg.as(:arg),
        c(
            a(str("alg"), arg),
            a(str("protocol"), arg),
            a(str("source-port"), arg),
            a(str("destination-port"), arg),
            a(str("icmp-type"), arg),
            a(str("icmp-code"), arg),
            a(str("icmp6-type"), arg),
            a(str("icmp6-code"), arg),
            a(str("rpc-program-number"), arg),
            a(str("uuid"), arg),
            a(str("inactivity-timeout"), arg)
        )
      ).as(:oneline)
    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("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)
                  )
              )
            )
        )
      )
    end

    rule(:three_color_policer_action) do
      b((str("high")).as(:arg),
        c(
            b(str("then"),
                c(
                    str("discard")
                )
            )
        )
      ).as(:oneline)
    end

    rule(:trace_file_type) do
        sca(
            a(str("size"), arg),
            a(str("files"), arg),
            str("world-readable"),
            str("no-world-readable")
        ).as(:oneline)
    end

    rule(:tty_port_object) do
        c(
            str("log-out-on-disconnect"),
            a(str("port-type"), arg),
            str("disable"),
            str("insecure"),
            a(str("type"), arg),
            str("silent-with-modem")
        )
    end

    rule(:tunable_object) do
      b(arg.as(:arg),
        c(
            a(str("tunable-value"), arg)
        )
      )
    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(:user_group_mapping_type) do
        c(
            b(str("ldap"),
                c(
                    a(str("authentication-algorithm"), arg),
                    str("ssl"),
                    a(str("base"), arg),
                    b(str("user"),
                        c(
                            a(str("user-name"), arg),
                            a(str("password"), arg)
                        )
                    ),
                    b(a(str("address"), arg),
                        c(
                            a(str("port"), arg)
                        )
                    )
                )
            )
        )
    end

    rule(:utm_apppxy_traceoptions) do
        c(
            a(str("flag"), 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("express-anti-virus") | str("mime") | str("regex-engine") | str("sophos-anti-virus") | str("all")).as(:oneline)
        )
    end

    rule(:utm_ipc_traceoptions) do
        c(
            a(str("flag"), 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"), str("cli") | str("daemon") | str("ipc") | str("pfe") | 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)
        )
    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")
                )
            ),
            a(str("use-interface-description"), arg)
        )
    end

    rule(:v6_server_group_type) do
        c(
            b(a(str("server-group"), arg),
                c(
                    a(str("address"), arg)
                )
            )
        )
    end

    rule(:version9_template) do
      b(arg.as(:arg),
        c(
            a(str("flow-active-timeout"), arg),
            a(str("flow-inactive-timeout"), arg),
            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"),
                a(str("label-position"), any)
              ),
              b(str("mpls-template"),
                a(str("label-position"), any)
              ),
              b(str("ipv6-template"),
                  c(
                      str("nexthop-options")
                  )
              ),
              str("peer-as-billing-template"),
              b(str("ipv4-template"),
                  c(
                      b(str("nexthop-options"),
                        b(str("mpls"),
                          a(str("label-position"), any)
                        )
                      )
                  )
              )
            )
        )
      )
    end

    rule(:vlan_type) do
      b(arg.as(:arg),
        c(
            a(str("description"), quote | arg),
            c(
              a(str("vlan-id"), arg),
              a(str("vlan-range"), arg)
            ),
            a(str("global-layer2-domainid"), arg),
            str("global-layer2-domainid-range"),
            b(a(str("interface"), arg),
                c(
                    str("pvlan-trunk"),
                    c(
                      str("ingress"),
                      str("egress")
                    ),
                    b(str("mapping"),
                        c(
                            b(str("mapping-data"),
                              vlan_mapping_type
                            ),
                            str("policy")
                        )
                    )
                )
            ),
            b(str("filter"),
                c(
                    c(
                      a(str("input"), arg)
                    ),
                    c(
                      a(str("output"), arg)
                    )
                )
            ),
            b(str("l3-interface"),
              interface_name
            ),
            str("l3-interface-ingress-counting"),
            b(str("mac-table-aging-time"),
              mac_aging_time_config
            ),
            b(str("mac-limit"),
                c(
                    a(str("limit"), arg),
                    a(str("action"), arg)
                )
            ).as(:oneline),
            b(str("dot1q-tunneling"),
                c(
                    a(str("customer-vlans"), arg),
                    b(str("layer2-protocol-tunneling"),
                        c(
                            b(str("l2pt-protocol"),
                              l2pt_proto_entry
                            )
                        )
                    )
                )
            ),
            str("no-local-switching"),
            a(str("isolation-id"), arg),
            a(str("primary-vlan"), arg),
            str("no-mac-learning")
        )
      )
    end

    rule(:l2pt_proto_entry) do
      b((str("all") | str("802.1x") | str("802.3ah") | str("cdp") | str("udld") | str("e-lmi") | str("gvrp") | str("lacp") | str("lldp") | str("mmrp") | str("mvrp") | str("stp") | str("vstp") | str("vtp")).as(:arg),
        c(
            a(str("drop-threshold"), arg),
            a(str("shutdown-threshold"), arg)
        )
      )
    end

    rule(:vlan_mapping_type) do
      b((str("native") | str("tag")).as(:arg),
        c(
            c(
              str("push"),
              str("swap")
            )
        )
      )
    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),
            a(str("inner-tag-protocol-id"), arg),
            a(str("vlan-id"), arg),
            a(str("inner-vlan-id"), arg)
        )
    end

    rule(:vpls_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(
                              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("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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | str("vrrp") | arg)
                              ),
                              b(str("ip-protocol-except"),
                                    (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("dstopts") | str("routing") | str("fragment") | str("no-next-header") | str("hop-by-hop") | 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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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") | str("range"))
                              ),
                              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") | str("range"))
                              )
                            ),
                            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("then"),
                        c(
                            c(
                              a(str("policer"), arg),
                              b(str("three-color-policer"),
                                  c(
                                      c(
                                        a(str("single-rate"), arg),
                                        a(str("two-rate"), arg)
                                      )
                                  )
                              ),
                              a(str("hierarchical-policer"), arg)
                            ),
                            a(str("count"), arg),
                            a(str("loss-priority"), arg),
                            a(str("forwarding-class"), arg),
                            c(
                              str("accept"),
                              str("discard"),
                              a(str("next"), arg)
                            ),
                            a(str("port-mirror-instance"), arg),
                            str("port-mirror"),
                            a(str("next-hop-group"), arg)
                        )
                    )
                )
            )
        )
      )
    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),
            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")
            ),
            a(str("authentication-type"), arg),
            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),
                                c(
                                    a(str("priority-cost"), arg)
                                )
                            ).as(:oneline),
                            a(str("priority-cost"), arg)
                        )
                    ),
                    b(str("route"),
                        s(
                          a(str("route_address"), 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(:webfilter_feature) do
        c(
            a(str("url-whitelist"), arg),
            a(str("url-blacklist"), arg),
            a(str("type"), arg),
            b(str("traceoptions"),
              web_filtering_traceoptions
            ),
            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(str("cache"),
                c(
                    a(str("timeout"), arg),
                    a(str("size"), arg)
                )
            ),
            b(str("server"),
              juniper_enhanced_server
            ),
            b(a(str("profile"), arg),
                c(
                    b(str("category"),
                      juniper_enhanced_category_type
                    ),
                    b(str("site-reputation-action"),
                      juniper_enhanced_site_reputation_setting
                    ),
                    a(str("default"), arg),
                    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_enhanced_category_type) do
      b(arg.as(:arg),
        c(
            a(str("action"), arg),
            b(str("reputation-action"),
              juniper_enhanced_site_reputation_setting
            )
        )
      )
    end

    rule(:juniper_enhanced_server) do
        c(
            a(str("host"), arg),
            a(str("port"), arg)
        )
    end

    rule(:juniper_enhanced_site_reputation_setting) do
        c(
            a(str("very-safe"), arg),
            a(str("moderately-safe"), arg),
            a(str("fairly-safe"), arg),
            a(str("suspicious"), arg),
            a(str("harmful"), arg)
        )
    end

    rule(:juniper_local_type) do
        c(
            b(a(str("profile"), arg),
                c(
                    a(str("default"), arg),
                    a(str("custom-block-message"), arg),
                    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
                    ),
                    a(str("default"), arg),
                    a(str("custom-block-message"), arg),
                    b(str("fallback-settings"),
                      web_filtering_fallback_setting
                    ),
                    a(str("timeout"), arg)
                )
            )
        )
    end

    rule(:server) do
        c(
            a(str("host"), arg),
            a(str("port"), arg)
        )
    end

    rule(:surf_control_integrated_category_type) do
      b(arg.as(:arg),
        c(
            a(str("action"), arg)
        )
      )
    end

    rule(:web_filtering_block_message) do
        c(
            a(str("type"), arg),
            a(str("url"), arg)
        )
    end

    rule(:web_filtering_fallback_setting) do
        c(
            a(str("default"), arg),
            a(str("server-connectivity"), arg),
            a(str("timeout"), arg),
            a(str("too-many-requests"), arg)
        )
    end

    rule(:web_filtering_quarantine_message) do
        c(
            a(str("type"), arg),
            a(str("url"), arg)
        )
    end

    rule(:web_filtering_traceoptions) do
        c(
            a(str("flag"), 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(:websense_type) do
        c(
            b(a(str("profile"), arg),
                c(
                    b(str("server"),
                      server
                    ),
                    a(str("custom-block-message"), arg),
                    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((str("all") | str("bfd") | str("bgp") | str("dvmrp") | str("igmp") | str("ldp") | str("msdp") | str("nhrp") | str("ospf") | str("ospf3") | 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((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("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((str("all") | 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("any-service")).as(:arg),
        c(
            str("except")
        )
      )
    end

    rule(:service_set_object) do
      b(arg.as(:arg),
        c(
          str("allow-multicast"),
          b(a(str("extension-service"), arg),
            any
          ),
          a(str("ids-rules"), arg),
          a(str("ids-rule-sets"), arg),
          b(str("interface-service"),
            a(str("service-interface"), arg)
          ),
          b(str("ipsec-vpn-options"),
            c(
              a(str("anti-replay-window-size"), arg),
              a(str("clear-dont-fragment-bit"), arg),
              a(str("ike-access-profile"), arg),
              a(str("local-gateway"), arg),
              str("no-anti-replay"),
              str("passive-mode-tunneling"),
              a(str("trusted-ca"), any),
              a(str("tunnel-mtu"), arg)
            )
          ),
          a(str("ip-reassembly-rules"), arg),
          a(str("ipsec-vpn-rules"), arg),
          a(str("ipsec-vpn-rule-sets"), arg),
          a(str("max-flows"), arg),
          b(str("max-drop-flows"),
            c(
              a(str("ingress"), arg),
              a(str("egress"), arg)
            )
          ),
          b(str("nat-options"),
            c(
              a(str("land-attack-check"), str("ip-only") | str("ip-port")),
              a(str("max-sessions-per-subscriber"), arg),
              b(str("stateful-nat64"),
                str("clear-dont-fragment-bit")
              )
            )
          ),
          a(str("nat-rules"), arg),
          a(str("nat-rule-sets"), arg),
          b(str("next-hop-service"),
            c(
              a(str("inside-service-interface"), dotted),
              a(str("outside-service-interface"), dotted),
              str("outside-service-interface-type local"),
              a(str("service-interface-pool"), arg)
            )
          ),
          a(str("pgcp-rules"), arg),
          a(str("pgcp-rule-sets"), arg),
          a(str("ptsp-rules"), arg),
          a(str("ptsp-rule-sets"), arg),
          b(str("service-set-options"),
            c(
              str("bypass-traffic-on-exceeding-flow-limits"),
              str("bypass-traffic-on-pic-failure"),
              str("enable-asymmetric-traffic-processing"),
              str("support-uni-directional-traffic")
            )
          ),
          b(str("snmp-trap-thresholds"),
            c(
              b(str("flows"),
                c(
                  a(str("high"), arg),
                  a(str("low"), arg)
                )
              ),
              b(str("nat-address-port"),
                c(
                  a(str("high"), arg),
                  a(str("low"), arg)
                )
              )
            )
          ),
          b(str("softwire-options"),
            a(str("dslite-ipv6-prefix-length"), arg)
          ),
          a(str("softwire-rules"), arg),
          a(str("softwire-rule-sets"), arg),
          a(str("stateful-firewall-rules"), arg),
          a(str("stateful-firewall-rule-sets"), arg),
          b(str("syslog"),
            b(a(str("host"), arg),
              b(str("class"),
                c(
                  str("alg-logs"),
                  str("ids-logs"),
                  str("nat-logs"),
                  str("packet-logs"),
                  str("pcp-logs"),
                  b(str("session-logs"),
                    c(
                      (str("open") | str("close")),
                      str("stateful-firewall-logs")
                    )
                  ),
                  a(str("services"), arg),
                  a(str("facility-override"), arg),
                  a(str("interface-service"), arg)
                )
              )
            )
          ),
          b(str("jflow-rules"),
            c(
              str("sampling")
            )
          ),
          b(str("sampling-service"),
            c(
              a(str("service-interface"), arg)
            )
          )
        )
      )
    end

    rule(:service_nat_object) do
      c(
        b(a(str("pool"), arg),
          c(
            a(str("address"), prefix),
            b(s(str("address-range"), str("low"), arg, str("high"), arg) | str("port"),
              c(
                a(str("automatic"), str("sequential") | str("random-allocation")),
                s(str("range"), str("low"), arg, str("high"), arg) | str("preserve-parity"),
                a(str("preserve-range"), any)
              )
            )
          )
        ),

        b(a(str("rule"), arg),
          c(
            a(str("match-direction"), str("input") | str("output")),
            b(a(str("term"), arg),
              c(
                b(str("from"),
                  c(
                    a(str("application-sets"), arg),
                    a(str("applications"), any),
                    b(str("destination-address"),
                      b((prefix | str("any-unicast")),
                        str("except")
                      )
                    ),
                    b(s(str("destination-address-range"), str("low"), arg, str("high"), arg),
                      str("except")
                    ),
                    b(str("source-address"),
                      b((prefix | str("any-unicast")),
                        str("except")
                      )
                    ),
                    b(s(str("source-address-range"), str("low"), arg, str("high"), arg),
                      str("except")
                    )
                  )
                ),
                b(str("then"),
                  c(
                    str("no-translation"),
                    b(str("translated"),
                      c(
                        str("address-pooling paired"),
                        a(str("destination-pool"), arg),
                        a(str("destination-prefix"), arg),
                        a(str("dns-alg-pool"), arg),
                        a(str("dns-alg-prefix"), arg),
                        a(str("filtering-type"), arg),
                        a(str("mapping-type"), arg),
                        a(str("overload-pool"), arg),
                        a(str("overload-prefix"), arg),
                        a(str("source-pool"), arg),
                        a(str("source-prefix"), arg),
                        b(str("translation-type"),
                          (str("basic-nat-pt") | str("basic-nat44") | str("basic-nat66") | str("dnat-44") | str("dynamic-nat44") | str("napt-44") | str("napt-66") | str("napt-pt") | str("stateful-nat64") | str("twice-basic-nat-44") | str("twice-dynamic-nat-44") | str("twice-napt-44"))
                        )
                      )
                    )
                  )
                ),
                str("syslog")
              )
            )
          )
        )
      )
    end

    rule(:storm_control) do
      c(
        str("default"),
        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(:app_engine_management_service) do
      c(
        str("disable"),
        b(str("traceoptions"),
          c(
            str("no-remote-trace"),
            b(str("file"),
              sca(
                a(str("size"), arg),
                a(str("files"), arg),
                str("world-readable"),
                str("no-world-readable"),
                b(str("match"),
                  regular_expression
                )
              )
            ).as(:oneline),
            a(str("level"), arg),
            a(str("flag"), str("active-directory-authentication") | str("configuration") | str("db") | str("ip-user-mapping") | str("ip-user-probe") | str("ipc") | str("user-group-mapping") | str("wmic") | str("all")).as(:oneline)
          )
        )
      )
    end

    rule(:juniper_protocols_sflow) do
      c(
        a(str("agent-id"), ipaddr),
        b(a(str("collector"), ipaddr),
          a(str("udp-port"), arg)
        ),
        b(a(str("interfaces"), arg),
          c(
            a(str("polling-interval"), arg),
            b(str("sample-rate"),
              c(
                a(str("egress"), arg),
                a(str("ingress"), arg),
              )
            )
          )
        ),
        a(str("polling-interval"), arg),
        b(str("sample-rate"),
          c(
            a(str("egress"), arg),
            a(str("ingress"), arg)
          )
        ),
        a(str("source-ip"), ipaddr),
        str("disable-sw-rate-limiter"),
        b(str("traceoptions"),
          c(
            b(str("file"),
              sca(
                a(str("files"), arg),
                str("no-stamp"),
                str("replace"),
                a(str("size"), arg),
                str("world-readable"),
                str("no-world-readable"),
                arg
              )
            ),
            a(str("flag"), str("all") | str("client-server") | str("configuration") | str("interface") | str("rtsock")).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
      (arg | str("all")).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
      (arg | str("all")).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(
            b(str("ip-address"),
              ipv4addr
            ),
            b(str("vlan"),
              pm_rspan_vlan
            ),
            b(str("bridge-domain"),
              pm_rspan_bridge_domain
            )
        )
      )
    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(:juniper_protocols_mpls) do
      c(
        c(
          str("disable")
        ),
        b(str("path-mtu"),
          c(
            str("allow-fragmentation"),
            b(str("rsvp"),
              c(
                str("mtu-signaling")
              )
            )
          )
        ),
        b(str("diffserv-te"),
          c(
            a(str("bandwidth-model"), arg),
            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"), 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"),
              trace_file_type
            ),
            a(str("interval"), arg),
            str("auto-bandwidth"),
            str("no-transit-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")
          )
        ),
        a(str("traffic-engineering"), arg),
        b(str("traceoptions"),
          c(
            b(str("file"),
              trace_file_type
            ),
            a(str("flag"), str("connection") | str("connection-detail") | str("cspf-link") | str("cspf-node") | str("cspf") | str("state") | str("error") | str("lsping") | str("graceful-restart") | str("nsr-synchronization") | str("nsr-synchronization-detail") | str("static") | str("egress-protection") | str("all")).as(:oneline)
          )
        ),
        b(a(str("admin-groups"), arg),
          c(
            a(str("group-value"), 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("explicit-null"),
        str("ipv6-tunneling"),
        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
        ),
        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),
        a(str("priority"), a(arg, arg)).as(:oneline),
        str("record"),
        str("no-record"),
        str("standby"),
        str("exclude-srlg"),
        b(str("admin-group"),
          admin_group_include_exclude
        ),
        b(str("admin-group-extended"),
          admin_group_include_exclude
        ),
        b(str("oam"),
          periodic_oam
        ),
        b(a(str("label-switched-path"), arg),
          c(
            c(
              str("disable")
            ),
            b(str("traceoptions"),
              c(
                b(str("file"),
                  trace_file_type
                ),
                a(str("flag"), str("cspf-link") | str("cspf-node") | str("cspf") | str("state") | str("all")).as(:oneline)
              )
            ),
            str("no-install-to-address"),
            str("backup"),
            b(str("from"),
              ipv4addr
            ),
            c(
              b(str("to"),
                ipv4addr
              ),
              str("template")
            ),
            a(str("metric"), arg),
            str("ldp-tunneling"),
            str("soft-preemption"),
            b(a(str("install"), arg),
              c(
                str("active")
              )
            ).as(:oneline),
            a(str("retry-timer"), arg),
            a(str("retry-limit"), arg),
            b(str("lsp-attributes"),
              c(
                a(str("signal-bandwidth"), arg),
                a(str("switching-type"), arg),
                a(str("encoding-type"), arg),
                a(str("gpid"), arg)
              )
            ),
            a(str("revert-timer"), arg),
            a(str("optimize-hold-dead-delay"), arg),
            b(str("bandwidth"),
              bandwidth_type
            ),
            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),
            a(str("priority"), a(arg, arg)).as(:oneline),
            str("record"),
            str("no-record"),
            str("standby"),
            str("exclude-srlg"),
            b(str("admin-group"),
              admin_group_include_exclude
            ),
            b(str("admin-group-extended"),
              admin_group_include_exclude
            ),
            b(str("oam"),
              periodic_oam
            ),
            c(
              str("random"),
              str("least-fill"),
              str("most-fill")
            ),
            a(str("description"), quote | arg),
            c(
              str("link-protection"),
              str("node-link-protection")
            ),
            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"),
              c(
                a(str("path_name"), arg)
              )
            ).as(:oneline),
            b(str("auto-bandwidth"),
              c(
                a(str("adjust-interval"), arg),
                a(str("adjust-threshold"), arg),
                a(str("minimum-bandwidth"), arg),
                a(str("maximum-bandwidth"), arg),
                str("monitor-bandwidth"),
                a(str("adjust-threshold-overflow-limit"), arg),
                a(str("adjust-threshold-underflow-limit"), arg)
              )
            ),
            b(a(str("associate-lsp"), arg),
              c(
                b(str("from"),
                  ipv4addr
                )
              )
            ),
            b(a(str("primary"), arg),
              c(
                b(str("bandwidth"),
                  bandwidth_type
                ),
                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),
                a(str("priority"), a(arg, arg)).as(:oneline),
                str("record"),
                str("no-record"),
                str("standby"),
                str("exclude-srlg"),
                b(str("admin-group"),
                  admin_group_include_exclude
                ),
                b(str("admin-group-extended"),
                  admin_group_include_exclude
                ),
                b(str("oam"),
                  periodic_oam
                ),
                str("adaptive"),
                a(str("select"), arg)
              )
            ),
            b(a(str("secondary"), arg),
              c(
                b(str("bandwidth"),
                  bandwidth_type
                ),
                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),
                a(str("priority"), a(arg, arg)).as(:oneline),
                str("record"),
                str("no-record"),
                str("standby"),
                str("exclude-srlg"),
                b(str("admin-group"),
                  admin_group_include_exclude
                ),
                b(str("admin-group-extended"),
                  admin_group_include_exclude
                ),
                b(str("oam"),
                  periodic_oam
                ),
                str("adaptive"),
                a(str("select"), arg)
              )
            ),
            b(str("policing"),
              c(
                a(str("filter"), arg),
                str("no-auto-policing")
              )
            ).as(:oneline),
            str("associate-backup-pe-groups"),
            str("egress-protection")
          )
        ),
        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(
                c(
                  str("loose"),
                  str("strict")
                )
              )
            ).as(:oneline)
          )
        ),
        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"),
                    ipv4addr_or_interface
                  ),
                  a(str("push"), arg),
                  b(str("to"),
                    ipv4addr
                  )
                )
              ),
              b(a(str("transit"), arg),
                c(
                  a(str("bandwidth"), arg),
                  a(str("description"), quote | arg),
                  b(str("link-protection"),
                    c(
                      a(str("bypass-name"), arg)
                    )
                  ).as(:oneline),
                  b(str("next-hop"),
                    ipv4addr_or_interface
                  ),
                  b(str("node-protection"),
                    c(
                      a(str("bypass-name"), arg),
                      a(str("next-next-label"), arg)
                    )
                  ).as(:oneline),
                  c(
                    a(str("swap"), arg),
                    str("pop")
                  )
                )
              ),
              b(str("ingress"),
                c(
                  a(str("bandwidth"), arg),
                  a(str("class-of-service"), arg),
                  a(str("description"), quote | arg),
                  b(a(str("install"), arg),
                    c(
                      str("active")
                    )
                  ).as(:oneline),
                  a(str("metric"), arg),
                  b(str("next-hop"),
                    ipv4addr_or_interface
                  ),
                  b(str("link-protection"),
                    c(
                      a(str("bypass-name"), arg)
                    )
                  ).as(:oneline),
                  b(str("node-protection"),
                    c(
                      a(str("bypass-name"), arg),
                      a(str("next-next-label"), arg)
                    )
                  ).as(:oneline),
                  str("no-install-to-address"),
                  b(str("policing"),
                    c(
                      a(str("filter"), arg),
                      str("no-auto-policing")
                    )
                  ).as(:oneline),
                  a(str("preference"), arg),
                  b(str("to"),
                    ipv4addr
                  ),
                  a(str("push"), arg)
                )
              )
            )
          )
        ),
        b(a(str("interface"), arg),
          c(
            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)
              )
            )
          )
        ),
        b(str("egress-protection"),
          c(
            b(a(str("context-identifier"), arg),
              c(
                c(
                  str("primary"),
                  str("protector")
                ),
                a(str("metric"), arg)
              )
            )
          )
        )
      )
    end
  end
end